diff --git a/TypeScript.YAML-tmLanguage b/TypeScript.YAML-tmLanguage
index acf8c10c..9a422a69 100644
--- a/TypeScript.YAML-tmLanguage
+++ b/TypeScript.YAML-tmLanguage
@@ -36,10 +36,13 @@ variables:
propertyName: ({{anyNumber}}|({{identifier}})|{{nonIdentifierPropertyName}})
propertyNameWithPrivate: ({{anyNumber}}|({{propertyIdentifier}})|{{nonIdentifierPropertyName}})
constantVar: ({{constantIdentifier}})(?![_$[:alnum:]])
- constructsAndModifiers: '(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b'
+ usingKeyword: '(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)'
+ awaitUsingKeyword: '(?:\bawait\s+{{usingKeyword}}\b)'
+ constructsAndModifiers: '(?:abstract|async|{{awaitUsingKeyword}}|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|{{usingKeyword}}|var|while)\b'
endOfStatement: ';|^\s*$|(?:^\s*{{constructsAndModifiers}})'
varExprStart: '{{startOfDeclaration}}\b(var|let){{endOfIdentifier}}'
constExprStart: '{{startOfDeclaration}}\b(const(?!\s+enum\b)){{endOfIdentifier}}'
+ usingExprStart: '{{startOfDeclaration}}\b({{usingKeyword}}|{{awaitUsingKeyword}}){{endOfIdentifier}}'
nonPropertyLookBehind: '[^\._$[:alnum:]]'
lookBehindReturn: '^return|{{nonPropertyLookBehind}}return'
lookBehindThrow: '^throw|{{nonPropertyLookBehind}}throw'
@@ -48,6 +51,8 @@ variables:
lookBehindDefault: '^default|{{nonPropertyLookBehind}}default'
lookBehindConst: '^const|{{nonPropertyLookBehind}}const'
lookBehindLet: '^let|{{nonPropertyLookBehind}}let'
+ lookBehindUsing: '^using|{{nonPropertyLookBehind}}using'
+ lookBehindAwaitUsing: '^await\s+using|{{nonPropertyLookBehind}}await\s+using'
lookBehindVar: '^var|{{nonPropertyLookBehind}}var'
lookBehindIn: '^in|{{nonPropertyLookBehind}}in'
lookBehindOf: '^of|{{nonPropertyLookBehind}}of'
@@ -134,7 +139,7 @@ variables:
# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
{{functionLikeType}} |
(:\s*(=>|{{matchingParenthesis}}|(<[^<>]*>)|[^<>(),=])+={{functionOrArrowLookup}})
- arrowFunctionEnd: (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+ arrowFunctionEnd: (?==>|\{|(^\s*(export|function|class|interface|let|var|{{usingKeyword}}|{{awaitUsingKeyword}}|const|import|enum|namespace|module|type|abstract|declare)\s+))
regexpTail: ([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$])
completeRegexp: \/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/{{regexpTail}})
@@ -322,6 +327,34 @@ repository:
- include: '#var-single-const'
- include: '#punctuation-comma'
- include: '#punctuation-comma'
+ # using/await using
+ - name: meta.var.expr.ts
+ begin: (?={{usingExprStart}})
+ beginCaptures:
+ '1': { name: keyword.control.export.ts }
+ '2': { name: storage.modifier.ts }
+ '3': { name: storage.type.ts }
+ end: (?!{{usingExprStart}})((?=;|}|({{startOfIdentifier}}(of|in)\s+)|{{endOfStatement}})|((?
end
- (?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -429,7 +429,7 @@
begin
(?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))
end
- (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$)))
+ (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$)))
patterns
@@ -539,7 +539,7 @@
end
- (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$)))
+ (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$)))
patterns
@@ -625,6 +625,108 @@
+
+ name
+ meta.var.expr.ts
+ begin
+ (?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))
+ beginCaptures
+
+ 1
+
+ name
+ keyword.control.export.ts
+
+ 2
+
+ name
+ storage.modifier.ts
+
+ 3
+
+ name
+ storage.type.ts
+
+
+ end
+ (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^using|[^\._$[:alnum:]]using|^await\s+using|[^\._$[:alnum:]]await\s+using)(?=\s*$)))
+ patterns
+
+
+ begin
+ (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*
+ beginCaptures
+
+ 1
+
+ name
+ keyword.control.export.ts
+
+ 2
+
+ name
+ storage.modifier.ts
+
+ 3
+
+ name
+ storage.type.ts
+
+
+ end
+ (?=\S)
+
+
+ include
+ #var-single-const
+
+
+ include
+ #variable-initializer
+
+
+ include
+ #comment
+
+
+ begin
+ (,)\s*((?!\S)|(?=\/\/))
+ beginCaptures
+
+ 1
+
+ name
+ punctuation.separator.comma.ts
+
+
+ end
+ (?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))
+ patterns
+
+
+ include
+ #single-line-comment-consuming-line-ending
+
+
+ include
+ #comment
+
+
+ include
+ #var-single-const
+
+
+ include
+ #punctuation-comma
+
+
+
+
+ include
+ #punctuation-comma
+
+
+
var-single-variable
@@ -719,7 +821,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -747,7 +849,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -775,7 +877,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -873,7 +975,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -896,7 +998,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -2116,7 +2218,7 @@
end
- (?=;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))|(?<=\})
+ (?=;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|(?<=\})
patterns
@@ -2574,7 +2676,7 @@
end
- (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+ (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+))
patterns
@@ -3098,7 +3200,7 @@
begin
(?<=:)\s*
end
- (?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3338,7 +3440,7 @@
end
- (?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3395,7 +3497,7 @@
end
- (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3423,7 +3525,7 @@
end
- (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3444,7 +3546,7 @@
end
- (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3743,7 +3845,7 @@
end
- (?=$|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3760,7 +3862,7 @@
name
meta.export.ts
begin
- (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?\b(?!(\$)|(\s*:))((?=\s*[\{*])|((?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s|,))(?!\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?\b(?!(\$)|(\s*:))((?=\s*[\{*])|((?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s|,))(?!\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
beginCaptures
1
@@ -3775,7 +3877,7 @@
end
- (?=$|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -5752,7 +5854,7 @@
end
- (?=[,);}\]=>:&|{\?]|(extends\s+)|$|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=[,);}\]=>:&|{\?]|(extends\s+)|$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -6945,7 +7047,7 @@
end
- (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+ (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+))
patterns
@@ -6967,7 +7069,7 @@
end
- (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+ (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+))
contentName
meta.arrow.ts meta.return.type.arrow.ts
patterns
diff --git a/TypeScriptReact.tmLanguage b/TypeScriptReact.tmLanguage
index a2c2db71..28c6d211 100644
--- a/TypeScriptReact.tmLanguage
+++ b/TypeScriptReact.tmLanguage
@@ -195,7 +195,7 @@
end
- (?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -433,7 +433,7 @@
begin
(?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))
end
- (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$)))
+ (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$)))
patterns
@@ -543,7 +543,7 @@
end
- (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$)))
+ (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$)))
patterns
@@ -629,6 +629,108 @@
+
+ name
+ meta.var.expr.tsx
+ begin
+ (?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))
+ beginCaptures
+
+ 1
+
+ name
+ keyword.control.export.tsx
+
+ 2
+
+ name
+ storage.modifier.tsx
+
+ 3
+
+ name
+ storage.type.tsx
+
+
+ end
+ (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^using|[^\._$[:alnum:]]using|^await\s+using|[^\._$[:alnum:]]await\s+using)(?=\s*$)))
+ patterns
+
+
+ begin
+ (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*
+ beginCaptures
+
+ 1
+
+ name
+ keyword.control.export.tsx
+
+ 2
+
+ name
+ storage.modifier.tsx
+
+ 3
+
+ name
+ storage.type.tsx
+
+
+ end
+ (?=\S)
+
+
+ include
+ #var-single-const
+
+
+ include
+ #variable-initializer
+
+
+ include
+ #comment
+
+
+ begin
+ (,)\s*((?!\S)|(?=\/\/))
+ beginCaptures
+
+ 1
+
+ name
+ punctuation.separator.comma.tsx
+
+
+ end
+ (?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))
+ patterns
+
+
+ include
+ #single-line-comment-consuming-line-ending
+
+
+ include
+ #comment
+
+
+ include
+ #var-single-const
+
+
+ include
+ #punctuation-comma
+
+
+
+
+ include
+ #punctuation-comma
+
+
+
var-single-variable
@@ -727,7 +829,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -755,7 +857,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -783,7 +885,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -885,7 +987,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -908,7 +1010,7 @@
end
- (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
patterns
@@ -2136,7 +2238,7 @@
end
- (?=;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))|(?<=\})
+ (?=;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|(?<=\})
patterns
@@ -2596,7 +2698,7 @@
end
- (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+ (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+))
patterns
@@ -3120,7 +3222,7 @@
begin
(?<=:)\s*
end
- (?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3360,7 +3462,7 @@
end
- (?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3417,7 +3519,7 @@
end
- (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3445,7 +3547,7 @@
end
- (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3466,7 +3568,7 @@
end
- (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3765,7 +3867,7 @@
end
- (?=$|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -3782,7 +3884,7 @@
name
meta.export.tsx
begin
- (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?\b(?!(\$)|(\s*:))((?=\s*[\{*])|((?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s|,))(?!\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b)))
+ (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?\b(?!(\$)|(\s*:))((?=\s*[\{*])|((?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s|,))(?!\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)))
beginCaptures
1
@@ -3797,7 +3899,7 @@
end
- (?=$|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -5698,7 +5800,7 @@
end
- (?=[,);}\]=>:&|{\?]|(extends\s+)|$|;|^\s*$|(?:^\s*(?:abstract|async|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|var|while)\b))
+ (?=[,);}\]=>:&|{\?]|(extends\s+)|$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))
patterns
@@ -6893,7 +6995,7 @@
end
- (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+ (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+))
patterns
@@ -6915,7 +7017,7 @@
end
- (?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))
+ (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+))
contentName
meta.arrow.tsx meta.return.type.arrow.tsx
patterns
diff --git a/tests/baselines/awaitUsing.baseline.txt b/tests/baselines/awaitUsing.baseline.txt
new file mode 100644
index 00000000..afef1344
--- /dev/null
+++ b/tests/baselines/awaitUsing.baseline.txt
@@ -0,0 +1,2474 @@
+original file
+-----------------------------------
+// await using as expression
+await using;
+await using = a;
+await using[x];
+await using[x] = a;
+await using.x;
+await using.x = a;
+[await using];
+[await using] = a;
+({x: await using});
+({x: await using} = a);
+a = await using;
+a = await using[x];
+a = [await using];
+a = {x: await using};
+async function f(a = await using) {}
+async () => await using;
+class C extends (await using) {}
+class C {}
+class C { [await using]; }
+class C { static [await using]; }
+class C { readonly [await using]; }
+class C { declare [await using]; }
+class C { abstract [await using]; }
+class C { accessor [await using]; }
+class C { static accessor [await using]; }
+class C { readonly accessor [await using]; }
+class C { [await using]() {} }
+class C { static [await using]() {} }
+class C { abstract [await using]() }
+class C { get [await using]() {} }
+class C { static get [await using]() {} }
+class C { abstract get [await using](); }
+class C { set [await using]() {} }
+class C { static set [await using](v) {} }
+class C { abstract set [await using](v); }
+enum E { a = await using };
+switch (await using) {
+ case await using:
+}
+for (await using;;);
+for (await using[x];;);
+
+await using
+x = a;
+
+await
+using
+x = a;
+
+await using
+[x] = a;
+
+await
+using
+[x] = a;
+
+// await using as keyword
+await using x = a;
+await using x = a, y = b;
+
+await using x
+= a;
+
+await using x
+= a, y = b;
+
+await using x = a
+ , y = b;
+
+await using x = a,
+ y = b;
+
+for (await using x of a);
+for (await using x = a;;);
+for (await using x = a, y = b;;);
+
+for (await using x
+= a;;);
+
+for (await using x
+= a, y = b;;);
+
+for (await using x = a
+ , y = b;;);
+
+for (await using x = a,
+ y = b;;);
+
+function f() {
+ await using x = a;
+}
+
+(() => {
+ await using x = a;
+})
+
+namespace N {
+ await using x = a;
+}
+
+class C {
+ constructor() {
+ await using x = a;
+ }
+ method() {
+ await using x = a;
+ }
+ get p() {
+ await using x = a;
+ }
+ set p(v) {
+ await using x = a;
+ }
+ static {
+ await using x = a;
+ }
+}
+
+// await using as expression, illegal syntax
+await using {x};
+await using {x: y};
+
+// await using as keyword, illegal syntax
+await using x;
+await using x, y;
+await using x, [y];
+await using x, {y};
+await using x, {y: z};
+await using x = a, y;
+await using x = a, [y];
+await using x = a, {y};
+await using x = a, {y: z};
+declare await using x;
+declare await using x = a;
+export await using x;
+export await using x = a;
+
+-----------------------------------
+
+Grammar: TypeScript.tmLanguage
+-----------------------------------
+>// await using as expression
+ ^^
+ source.ts comment.line.double-slash.ts punctuation.definition.comment.ts
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ source.ts comment.line.double-slash.ts
+>await using;
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using = a;
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using[x];
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using[x] = a;
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using.x;
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.object.ts
+ ^
+ source.ts punctuation.accessor.ts
+ ^
+ source.ts support.variable.property.dom.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using.x = a;
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.object.ts
+ ^
+ source.ts punctuation.accessor.ts
+ ^
+ source.ts support.variable.property.dom.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>[await using];
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>[await using] = a;
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({x: await using});
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts keyword.control.flow.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({x: await using} = a);
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts keyword.control.flow.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = await using;
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = await using[x];
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = [await using];
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.array.literal.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = {x: await using};
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.objectliteral.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts keyword.control.flow.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>async function f(a = await using) {}
+ ^^^^^
+ source.ts meta.function.ts storage.modifier.async.ts
+ ^
+ source.ts meta.function.ts
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^^^^^
+ source.ts meta.function.ts meta.parameters.ts keyword.control.flow.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^^^^^
+ source.ts meta.function.ts meta.parameters.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>async () => await using;
+ ^^^^^
+ source.ts meta.arrow.ts storage.modifier.async.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>class C extends (await using) {}
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts meta.brace.round.ts
+ ^^^^^
+ source.ts meta.class.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^
+ source.ts meta.class.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.brace.round.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C {}
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts
+ ^^^^^
+ source.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts
+ ^
+ source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { [await using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static [await using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { readonly [await using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { declare [await using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract [await using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { accessor [await using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static accessor [await using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { readonly accessor [await using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { [await using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static [await using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract [await using]() }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { get [await using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static get [await using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract get [await using](); }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { set [await using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static set [await using](v) {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract set [await using](v); }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts keyword.control.flow.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>enum E { a = await using };
+ ^^^^
+ source.ts meta.enum.declaration.ts storage.type.enum.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts entity.name.type.enum.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts variable.other.enummember.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^^^^^
+ source.ts meta.enum.declaration.ts keyword.control.flow.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^^^^^
+ source.ts meta.enum.declaration.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>switch (await using) {
+ ^^^^^^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.switch.ts
+ ^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts
+ ^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts
+ ^^^^^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.flow.ts
+ ^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts
+ ^^^^^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts
+ ^
+ source.ts switch-statement.expr.ts
+ ^
+ source.ts switch-statement.expr.ts switch-block.expr.ts punctuation.definition.block.ts
+> case await using:
+ ^^^^
+ source.ts switch-statement.expr.ts switch-block.expr.ts
+ ^^^^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts
+ ^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts
+ ^^^^^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.flow.ts
+ ^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts
+ ^^^^^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts
+>}
+ ^
+ source.ts switch-statement.expr.ts punctuation.definition.block.ts
+>for (await using;;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (await using[x];;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>await using
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+>x = a;
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>await
+ ^^^^^
+ source.ts keyword.control.flow.ts
+>using
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+>x = a;
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>await using
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+>[x] = a;
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>await
+ ^^^^^
+ source.ts keyword.control.flow.ts
+>using
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+>[x] = a;
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>// await using as keyword
+ ^^
+ source.ts comment.line.double-slash.ts punctuation.definition.comment.ts
+ ^^^^^^^^^^^^^^^^^^^^^^^
+ source.ts comment.line.double-slash.ts
+>await using x = a;
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x = a, y = b;
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>await using x
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+>= a;
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>await using x
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+>= a, y = b;
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.separator.comma.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>await using x = a
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+> , y = b;
+ ^^^^
+ source.ts
+ ^
+ source.ts punctuation.separator.comma.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>await using x = a,
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+> y = b;
+ ^^^^^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (await using x of a);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^^
+ source.ts keyword.operator.expression.of.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (await using x = a;;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (await using x = a, y = b;;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (await using x
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+>= a;;);
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (await using x
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+>= a, y = b;;);
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.separator.comma.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (await using x = a
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+> , y = b;;);
+ ^^^^^^^^^
+ source.ts
+ ^
+ source.ts punctuation.separator.comma.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (await using x = a,
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+> y = b;;);
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>function f() {
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+> await using x = a;
+ ^^^^
+ source.ts meta.function.ts meta.block.ts
+ ^^^^^^^^^^^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts
+>}
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>
+ ^
+ source.ts
+>(() => {
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+> await using x = a;
+ ^^^^
+ source.ts meta.arrow.ts meta.block.ts
+ ^^^^^^^^^^^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts
+>})
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.brace.round.ts
+>
+ ^
+ source.ts
+>namespace N {
+ ^^^^^^^^^
+ source.ts meta.namespace.declaration.ts storage.type.namespace.ts
+ ^
+ source.ts meta.namespace.declaration.ts
+ ^
+ source.ts meta.namespace.declaration.ts entity.name.type.module.ts
+ ^
+ source.ts meta.namespace.declaration.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts
+> await using x = a;
+ ^^^^
+ source.ts meta.namespace.declaration.ts meta.block.ts
+ ^^^^^^^^^^^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+>}
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts
+>
+ ^
+ source.ts
+>class C {
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+> constructor() {
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> await using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^^^^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> method() {
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> await using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^^^^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> get p() {
+ ^^^^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> await using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^^^^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> set p(v) {
+ ^^^^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> await using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^^^^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> static {
+ ^^^^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts
+> await using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.block.ts
+ ^^^^^^^^^^^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts
+>}
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>
+ ^
+ source.ts
+>// await using as expression, illegal syntax
+ ^^
+ source.ts comment.line.double-slash.ts punctuation.definition.comment.ts
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ source.ts comment.line.double-slash.ts
+>await using {x};
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.block.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using {x: y};
+ ^^^^^
+ source.ts keyword.control.flow.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.block.ts entity.name.label.ts
+ ^
+ source.ts meta.block.ts punctuation.separator.label.ts
+ ^
+ source.ts meta.block.ts
+ ^
+ source.ts meta.block.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>// await using as keyword, illegal syntax
+ ^^
+ source.ts comment.line.double-slash.ts punctuation.definition.comment.ts
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ source.ts comment.line.double-slash.ts
+>await using x;
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x, y;
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x, [y];
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x, {y};
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x, {y: z};
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts
+ ^
+ source.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x = a, y;
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x = a, [y];
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x = a, {y};
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>await using x = a, {y: z};
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts
+ ^
+ source.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>declare await using x;
+ ^^^^^^^
+ source.ts meta.var.expr.ts storage.modifier.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>declare await using x = a;
+ ^^^^^^^
+ source.ts meta.var.expr.ts storage.modifier.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>export await using x;
+ ^^^^^^
+ source.ts meta.var.expr.ts keyword.control.export.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>export await using x = a;
+ ^^^^^^
+ source.ts meta.var.expr.ts keyword.control.export.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
\ No newline at end of file
diff --git a/tests/baselines/using.baseline.txt b/tests/baselines/using.baseline.txt
new file mode 100644
index 00000000..2b5028e8
--- /dev/null
+++ b/tests/baselines/using.baseline.txt
@@ -0,0 +1,3916 @@
+original file
+-----------------------------------
+// using as identifier
+using;
+using = a;
+using[x];
+using[x] = a;
+using.x;
+using.x = a;
+[using];
+[using] = a;
+({using});
+({using} = a);
+({using: x});
+({using: x} = a);
+({x: using});
+({x: using} = a);
+a = using;
+a = using[x];
+a = [using];
+a = {using};
+a = {using: x};
+a = {x: using};
+var using;
+var using = a;
+var [using];
+var [using] = a;
+let using;
+let using = a;
+let [using];
+let [using] = a;
+const using;
+const using = a;
+const [using];
+const [using] = a;
+function using() {}
+function f(using) {}
+function f(using = a) {}
+function f(using[x]) {}
+function f(using[x] = a) {}
+function f(a = using) {}
+using => {};
+(using) => {};
+([using]) => {};
+({using}) => {};
+({using: x}) => {};
+({x: using}) => {};
+() => using;
+async using => {};
+async (using) => {};
+class using {}
+class C extends using {}
+class C {}
+class C { using; }
+class C { static using; }
+class C { readonly using; }
+class C { declare using; }
+class C { abstract using; }
+class C { accessor using; }
+class C { static accessor using; }
+class C { readonly accessor using; }
+class C { using() {} }
+class C { static using() {} }
+class C { abstract using() }
+class C { get using() {} }
+class C { static get using() {} }
+class C { abstract get using(); }
+class C { set using() {} }
+class C { static set using(v) {} }
+class C { abstract set using(v); }
+class C { [using]; }
+class C { static [using]; }
+class C { readonly [using]; }
+class C { declare [using]; }
+class C { abstract [using]; }
+class C { accessor [using]; }
+class C { static accessor [using]; }
+class C { readonly accessor [using]; }
+class C { [using]() {} }
+class C { static [using]() {} }
+class C { abstract [using]() }
+class C { get [using]() {} }
+class C { static get [using]() {} }
+class C { abstract get [using](); }
+class C { set [using]() {} }
+class C { static set [using](v) {} }
+class C { abstract set [using](v); }
+namespace using {}
+namespace using.x {}
+interface using {}
+interface I { [using: string]: using; }
+type using = never;
+type X = never;
+enum using {}
+enum E { using };
+enum E { a = using };
+using: {};
+break using;
+continue using;
+switch (using) {
+ case using:
+}
+export { using };
+export { using as x };
+export { x as using };
+import using from "";
+import * as using from "";
+import { using } from "";
+import { using as x } from "";
+import { x as using } from "";
+for (using;;);
+for (using = a;;);
+for (using[x];;);
+for (using[x] = a;;);
+for (using in a);
+for (using of a);
+
+using
+x = a;
+
+using
+[x] = a;
+
+// using as keyword
+using x = a;
+using x = a, y = b;
+
+using x
+= a;
+
+using x
+= a, y = b;
+
+using x = a
+ , y = b;
+
+using x = a,
+ y = b;
+
+for (using x of a);
+for (using x = a;;);
+for (using x = a, y = b;;);
+
+for (using x
+= a;;);
+
+for (using x
+= a, y = b;;);
+
+for (using x = a
+ , y = b;;);
+
+for (using x = a,
+ y = b;;);
+
+function f() {
+ using x = a;
+}
+
+(() => {
+ using x = a;
+})
+
+namespace N {
+ using x = a;
+}
+
+class C {
+ constructor() {
+ using x = a;
+ }
+ method() {
+ using x = a;
+ }
+ get p() {
+ using x = a;
+ }
+ set p(v) {
+ using x = a;
+ }
+ static {
+ using x = a;
+ }
+}
+
+// using as identifier, illegal syntax
+using {x};
+using {x: y};
+
+// using as keyword, illegal syntax
+using x;
+using x, y;
+using x, [y];
+using x, {y};
+using x, {y: z};
+using x = a, y;
+using x = a, [y];
+using x = a, {y};
+using x = a, {y: z};
+declare using x;
+declare using x = a;
+export using x;
+export using x = a;
+
+-----------------------------------
+
+Grammar: TypeScript.tmLanguage
+-----------------------------------
+>// using as identifier
+ ^^
+ source.ts comment.line.double-slash.ts punctuation.definition.comment.ts
+ ^^^^^^^^^^^^^^^^^^^^
+ source.ts comment.line.double-slash.ts
+>using;
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using = a;
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using[x];
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using[x] = a;
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using.x;
+ ^^^^^
+ source.ts variable.other.object.ts
+ ^
+ source.ts punctuation.accessor.ts
+ ^
+ source.ts support.variable.property.dom.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using.x = a;
+ ^^^^^
+ source.ts variable.other.object.ts
+ ^
+ source.ts punctuation.accessor.ts
+ ^
+ source.ts support.variable.property.dom.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>[using];
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>[using] = a;
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({using});
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({using} = a);
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({using: x});
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({using: x} = a);
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({x: using});
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({x: using} = a);
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = using;
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = using[x];
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = [using];
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.array.literal.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = {using};
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.objectliteral.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = {using: x};
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.objectliteral.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>a = {x: using};
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.objectliteral.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts
+ ^
+ source.ts meta.objectliteral.ts meta.object.member.ts
+ ^^^^^
+ source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.objectliteral.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>var using;
+ ^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>var using = a;
+ ^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>var [using];
+ ^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts meta.definition.variable.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>var [using] = a;
+ ^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts meta.definition.variable.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>let using;
+ ^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>let using = a;
+ ^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>let [using];
+ ^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts meta.definition.variable.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>let [using] = a;
+ ^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts meta.definition.variable.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>const using;
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>const using = a;
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>const [using];
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>const [using] = a;
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^^^^^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>function using() {}
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^^^^^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>function f(using) {}
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^^^^^
+ source.ts meta.function.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>function f(using = a) {}
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^^^^^
+ source.ts meta.function.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>function f(using[x]) {}
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^^^^^
+ source.ts meta.function.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts variable.parameter.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>function f(using[x] = a) {}
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^^^^^
+ source.ts meta.function.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts variable.parameter.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>function f(a = using) {}
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts
+ ^^^^^
+ source.ts meta.function.ts meta.parameters.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>using => {};
+ ^^^^^
+ source.ts meta.arrow.ts variable.parameter.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>(using) => {};
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^^^^^
+ source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>([using]) => {};
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts punctuation.definition.binding-pattern.array.ts
+ ^^^^^
+ source.ts meta.arrow.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts variable.parameter.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.paramter.array-binding-pattern.ts punctuation.definition.binding-pattern.array.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({using}) => {};
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts
+ ^^^^^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts variable.parameter.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({using: x}) => {};
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts
+ ^^^^^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts variable.object.property.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.destructuring.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts variable.parameter.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>({x: using}) => {};
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts variable.object.property.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.destructuring.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts
+ ^^^^^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts variable.parameter.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>() => using;
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>async using => {};
+ ^^^^^
+ source.ts meta.arrow.ts storage.modifier.async.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^^^^
+ source.ts meta.arrow.ts variable.parameter.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>async (using) => {};
+ ^^^^^
+ source.ts meta.arrow.ts storage.modifier.async.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^^^^^
+ source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>class using {}
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C extends using {}
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^
+ source.ts meta.class.ts entity.other.inherited-class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C {}
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts
+ ^^^^^
+ source.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts
+ ^
+ source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { using; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static using; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { readonly using; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { declare using; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract using; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { accessor using; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static accessor using; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { readonly accessor using; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { using() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static using() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract using() }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { get using() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static get using() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract get using(); }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { set using() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static set using(v) {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract set using(v); }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { [using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static [using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { readonly [using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { declare [using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract [using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { accessor [using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static accessor [using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { readonly accessor [using]; }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { [using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static [using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.array.literal.ts
+ ^
+ source.ts meta.class.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract [using]() }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { get [using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static get [using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract get [using](); }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { set [using]() {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { static set [using](v) {} }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>class C { abstract set [using](v); }
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.class.ts
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>namespace using {}
+ ^^^^^^^^^
+ source.ts meta.namespace.declaration.ts storage.type.namespace.ts
+ ^
+ source.ts meta.namespace.declaration.ts
+ ^^^^^
+ source.ts meta.namespace.declaration.ts entity.name.type.module.ts
+ ^
+ source.ts meta.namespace.declaration.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts
+>namespace using.x {}
+ ^^^^^^^^^
+ source.ts meta.namespace.declaration.ts storage.type.namespace.ts
+ ^
+ source.ts meta.namespace.declaration.ts
+ ^^^^^
+ source.ts meta.namespace.declaration.ts entity.name.type.module.ts
+ ^
+ source.ts meta.namespace.declaration.ts punctuation.accessor.ts
+ ^
+ source.ts meta.namespace.declaration.ts entity.name.type.module.ts
+ ^
+ source.ts meta.namespace.declaration.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts
+>interface using {}
+ ^^^^^^^^^
+ source.ts meta.interface.ts storage.type.interface.ts
+ ^
+ source.ts meta.interface.ts
+ ^^^^^
+ source.ts meta.interface.ts entity.name.type.interface.ts
+ ^
+ source.ts meta.interface.ts
+ ^
+ source.ts meta.interface.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.interface.ts punctuation.definition.block.ts
+>interface I { [using: string]: using; }
+ ^^^^^^^^^
+ source.ts meta.interface.ts storage.type.interface.ts
+ ^
+ source.ts meta.interface.ts
+ ^
+ source.ts meta.interface.ts entity.name.type.interface.ts
+ ^
+ source.ts meta.interface.ts
+ ^
+ source.ts meta.interface.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.interface.ts meta.indexer.declaration.ts
+ ^
+ source.ts meta.interface.ts meta.indexer.declaration.ts meta.brace.square.ts
+ ^^^^^
+ source.ts meta.interface.ts meta.indexer.declaration.ts variable.parameter.ts
+ ^
+ source.ts meta.interface.ts meta.indexer.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts
+ ^
+ source.ts meta.interface.ts meta.indexer.declaration.ts meta.type.annotation.ts
+ ^^^^^^
+ source.ts meta.interface.ts meta.indexer.declaration.ts meta.type.annotation.ts support.type.primitive.ts
+ ^
+ source.ts meta.interface.ts meta.indexer.declaration.ts meta.brace.square.ts
+ ^
+ source.ts meta.interface.ts meta.type.annotation.ts keyword.operator.type.annotation.ts
+ ^
+ source.ts meta.interface.ts meta.type.annotation.ts
+ ^^^^^
+ source.ts meta.interface.ts meta.type.annotation.ts entity.name.type.ts
+ ^
+ source.ts meta.interface.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.interface.ts
+ ^
+ source.ts meta.interface.ts punctuation.definition.block.ts
+>type using = never;
+ ^^^^
+ source.ts meta.type.declaration.ts storage.type.type.ts
+ ^
+ source.ts meta.type.declaration.ts
+ ^^^^^
+ source.ts meta.type.declaration.ts entity.name.type.alias.ts
+ ^
+ source.ts meta.type.declaration.ts
+ ^
+ source.ts meta.type.declaration.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.type.declaration.ts
+ ^^^^^
+ source.ts meta.type.declaration.ts support.type.primitive.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>type X = never;
+ ^^^^
+ source.ts meta.type.declaration.ts storage.type.type.ts
+ ^
+ source.ts meta.type.declaration.ts
+ ^
+ source.ts meta.type.declaration.ts entity.name.type.alias.ts
+ ^
+ source.ts meta.type.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts
+ ^^^^^
+ source.ts meta.type.declaration.ts meta.type.parameters.ts entity.name.type.ts
+ ^
+ source.ts meta.type.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts
+ ^
+ source.ts meta.type.declaration.ts
+ ^
+ source.ts meta.type.declaration.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.type.declaration.ts
+ ^^^^^
+ source.ts meta.type.declaration.ts support.type.primitive.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>enum using {}
+ ^^^^
+ source.ts meta.enum.declaration.ts storage.type.enum.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^^^^^
+ source.ts meta.enum.declaration.ts entity.name.type.enum.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.enum.declaration.ts punctuation.definition.block.ts
+>enum E { using };
+ ^^^^
+ source.ts meta.enum.declaration.ts storage.type.enum.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts entity.name.type.enum.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^^^^^
+ source.ts meta.enum.declaration.ts variable.other.enummember.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>enum E { a = using };
+ ^^^^
+ source.ts meta.enum.declaration.ts storage.type.enum.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts entity.name.type.enum.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts variable.other.enummember.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^^^^^
+ source.ts meta.enum.declaration.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.enum.declaration.ts
+ ^
+ source.ts meta.enum.declaration.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using: {};
+ ^^^^^
+ source.ts entity.name.label.ts
+ ^
+ source.ts punctuation.separator.label.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>break using;
+ ^^^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts entity.name.label.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>continue using;
+ ^^^^^^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^^^^^
+ source.ts entity.name.label.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>switch (using) {
+ ^^^^^^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.switch.ts
+ ^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts
+ ^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts
+ ^^^^^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts
+ ^
+ source.ts switch-statement.expr.ts
+ ^
+ source.ts switch-statement.expr.ts switch-block.expr.ts punctuation.definition.block.ts
+> case using:
+ ^^^^
+ source.ts switch-statement.expr.ts switch-block.expr.ts
+ ^^^^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts
+ ^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts
+ ^^^^^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts
+>}
+ ^
+ source.ts switch-statement.expr.ts punctuation.definition.block.ts
+>export { using };
+ ^^^^^^
+ source.ts meta.export.ts keyword.control.export.ts
+ ^
+ source.ts meta.export.ts
+ ^
+ source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^^^^^
+ source.ts meta.export.ts meta.block.ts variable.other.readwrite.alias.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^
+ source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>export { using as x };
+ ^^^^^^
+ source.ts meta.export.ts keyword.control.export.ts
+ ^
+ source.ts meta.export.ts
+ ^
+ source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^^^^^
+ source.ts meta.export.ts meta.block.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^^
+ source.ts meta.export.ts meta.block.ts keyword.control.as.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^
+ source.ts meta.export.ts meta.block.ts variable.other.readwrite.alias.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^
+ source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>export { x as using };
+ ^^^^^^
+ source.ts meta.export.ts keyword.control.export.ts
+ ^
+ source.ts meta.export.ts
+ ^
+ source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^
+ source.ts meta.export.ts meta.block.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^^
+ source.ts meta.export.ts meta.block.ts keyword.control.as.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^^^^^
+ source.ts meta.export.ts meta.block.ts variable.other.readwrite.alias.ts
+ ^
+ source.ts meta.export.ts meta.block.ts
+ ^
+ source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>import using from "";
+ ^^^^^^
+ source.ts meta.import.ts keyword.control.import.ts
+ ^
+ source.ts meta.import.ts
+ ^^^^^
+ source.ts meta.import.ts variable.other.readwrite.alias.ts
+ ^
+ source.ts meta.import.ts
+ ^^^^
+ source.ts meta.import.ts keyword.control.from.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.begin.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.end.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>import * as using from "";
+ ^^^^^^
+ source.ts meta.import.ts keyword.control.import.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts constant.language.import-export-all.ts
+ ^
+ source.ts meta.import.ts
+ ^^
+ source.ts meta.import.ts keyword.control.as.ts
+ ^
+ source.ts meta.import.ts
+ ^^^^^
+ source.ts meta.import.ts variable.other.readwrite.alias.ts
+ ^
+ source.ts meta.import.ts
+ ^^^^
+ source.ts meta.import.ts keyword.control.from.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.begin.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.end.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>import { using } from "";
+ ^^^^^^
+ source.ts meta.import.ts keyword.control.import.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^^^^^
+ source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^
+ source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.import.ts
+ ^^^^
+ source.ts meta.import.ts keyword.control.from.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.begin.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.end.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>import { using as x } from "";
+ ^^^^^^
+ source.ts meta.import.ts keyword.control.import.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^^^^^
+ source.ts meta.import.ts meta.block.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^^
+ source.ts meta.import.ts meta.block.ts keyword.control.as.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^
+ source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^
+ source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.import.ts
+ ^^^^
+ source.ts meta.import.ts keyword.control.from.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.begin.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.end.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>import { x as using } from "";
+ ^^^^^^
+ source.ts meta.import.ts keyword.control.import.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^
+ source.ts meta.import.ts meta.block.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^^
+ source.ts meta.import.ts meta.block.ts keyword.control.as.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^^^^^
+ source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts
+ ^
+ source.ts meta.import.ts meta.block.ts
+ ^
+ source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.import.ts
+ ^^^^
+ source.ts meta.import.ts keyword.control.from.ts
+ ^
+ source.ts meta.import.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.begin.ts
+ ^
+ source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.end.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (using;;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (using = a;;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (using[x];;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (using[x] = a;;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (using in a);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^^
+ source.ts keyword.operator.expression.in.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (using of a);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^^
+ source.ts keyword.operator.expression.of.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>using
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+>x = a;
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>using
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+>[x] = a;
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts meta.array.literal.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.array.literal.ts meta.brace.square.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>// using as keyword
+ ^^
+ source.ts comment.line.double-slash.ts punctuation.definition.comment.ts
+ ^^^^^^^^^^^^^^^^^
+ source.ts comment.line.double-slash.ts
+>using x = a;
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x = a, y = b;
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>using x
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+>= a;
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>using x
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+>= a, y = b;
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.separator.comma.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>using x = a
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+> , y = b;
+ ^^^^
+ source.ts
+ ^
+ source.ts punctuation.separator.comma.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>using x = a,
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+> y = b;
+ ^^^^^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (using x of a);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^^
+ source.ts keyword.operator.expression.of.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (using x = a;;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>for (using x = a, y = b;;);
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (using x
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+>= a;;);
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (using x
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+>= a, y = b;;);
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.separator.comma.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (using x = a
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+> , y = b;;);
+ ^^^^^^^^^
+ source.ts
+ ^
+ source.ts punctuation.separator.comma.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts keyword.operator.assignment.ts
+ ^
+ source.ts
+ ^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>for (using x = a,
+ ^^^
+ source.ts keyword.control.loop.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+> y = b;;);
+ ^^^^^^^^^^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>function f() {
+ ^^^^^^^^
+ source.ts meta.function.ts storage.type.function.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.function.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+> using x = a;
+ ^^^^
+ source.ts meta.function.ts meta.block.ts
+ ^^^^^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts
+>}
+ ^
+ source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts
+>
+ ^
+ source.ts
+>(() => {
+ ^
+ source.ts meta.brace.round.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.arrow.ts
+ ^^
+ source.ts meta.arrow.ts storage.type.function.arrow.ts
+ ^
+ source.ts meta.arrow.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+> using x = a;
+ ^^^^
+ source.ts meta.arrow.ts meta.block.ts
+ ^^^^^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts
+>})
+ ^
+ source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.brace.round.ts
+>
+ ^
+ source.ts
+>namespace N {
+ ^^^^^^^^^
+ source.ts meta.namespace.declaration.ts storage.type.namespace.ts
+ ^
+ source.ts meta.namespace.declaration.ts
+ ^
+ source.ts meta.namespace.declaration.ts entity.name.type.module.ts
+ ^
+ source.ts meta.namespace.declaration.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts
+> using x = a;
+ ^^^^
+ source.ts meta.namespace.declaration.ts meta.block.ts
+ ^^^^^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+>}
+ ^
+ source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts
+>
+ ^
+ source.ts
+>class C {
+ ^^^^^
+ source.ts meta.class.ts storage.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts entity.name.type.class.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+> constructor() {
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> method() {
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> get p() {
+ ^^^^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> set p(v) {
+ ^^^^
+ source.ts meta.class.ts
+ ^^^
+ source.ts meta.class.ts meta.method.declaration.ts storage.type.property.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts
+> static {
+ ^^^^
+ source.ts meta.class.ts
+ ^^^^^^
+ source.ts meta.class.ts storage.modifier.ts
+ ^
+ source.ts meta.class.ts
+ ^
+ source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts
+> using x = a;
+ ^^^^^^^^
+ source.ts meta.class.ts meta.block.ts
+ ^^^^^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts
+ ^
+ source.ts meta.class.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.class.ts meta.block.ts punctuation.terminator.statement.ts
+> }
+ ^^^^
+ source.ts meta.class.ts meta.block.ts
+ ^
+ source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts
+>}
+ ^
+ source.ts meta.class.ts punctuation.definition.block.ts
+>
+ ^
+ source.ts
+>// using as identifier, illegal syntax
+ ^^
+ source.ts comment.line.double-slash.ts punctuation.definition.comment.ts
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ source.ts comment.line.double-slash.ts
+>using {x};
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.block.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using {x: y};
+ ^^^^^
+ source.ts variable.other.readwrite.ts
+ ^
+ source.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts meta.block.ts entity.name.label.ts
+ ^
+ source.ts meta.block.ts punctuation.separator.label.ts
+ ^
+ source.ts meta.block.ts
+ ^
+ source.ts meta.block.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.block.ts punctuation.definition.block.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
+>// using as keyword, illegal syntax
+ ^^
+ source.ts comment.line.double-slash.ts punctuation.definition.comment.ts
+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ source.ts comment.line.double-slash.ts
+>using x;
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x, y;
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x, [y];
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x, {y};
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x, {y: z};
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts
+ ^
+ source.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x = a, y;
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x = a, [y];
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x = a, {y};
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>using x = a, {y: z};
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts meta.var.expr.ts punctuation.separator.comma.ts
+ ^^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts
+ ^
+ source.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>declare using x;
+ ^^^^^^^
+ source.ts meta.var.expr.ts storage.modifier.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>declare using x = a;
+ ^^^^^^^
+ source.ts meta.var.expr.ts storage.modifier.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>export using x;
+ ^^^^^^
+ source.ts meta.var.expr.ts keyword.control.export.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>export using x = a;
+ ^^^^^^
+ source.ts meta.var.expr.ts keyword.control.export.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^^^^^
+ source.ts meta.var.expr.ts storage.type.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts
+ ^
+ source.ts meta.var.expr.ts meta.var-single-variable.expr.ts
+ ^
+ source.ts meta.var.expr.ts keyword.operator.assignment.ts
+ ^
+ source.ts meta.var.expr.ts
+ ^
+ source.ts meta.var.expr.ts variable.other.readwrite.ts
+ ^
+ source.ts punctuation.terminator.statement.ts
+>
+ ^
+ source.ts
\ No newline at end of file
diff --git a/tests/cases/awaitUsing.ts b/tests/cases/awaitUsing.ts
new file mode 100644
index 00000000..1d461dcd
--- /dev/null
+++ b/tests/cases/awaitUsing.ts
@@ -0,0 +1,137 @@
+// await using as expression
+await using;
+await using = a;
+await using[x];
+await using[x] = a;
+await using.x;
+await using.x = a;
+[await using];
+[await using] = a;
+({x: await using});
+({x: await using} = a);
+a = await using;
+a = await using[x];
+a = [await using];
+a = {x: await using};
+async function f(a = await using) {}
+async () => await using;
+class C extends (await using) {}
+class C {}
+class C { [await using]; }
+class C { static [await using]; }
+class C { readonly [await using]; }
+class C { declare [await using]; }
+class C { abstract [await using]; }
+class C { accessor [await using]; }
+class C { static accessor [await using]; }
+class C { readonly accessor [await using]; }
+class C { [await using]() {} }
+class C { static [await using]() {} }
+class C { abstract [await using]() }
+class C { get [await using]() {} }
+class C { static get [await using]() {} }
+class C { abstract get [await using](); }
+class C { set [await using]() {} }
+class C { static set [await using](v) {} }
+class C { abstract set [await using](v); }
+enum E { a = await using };
+switch (await using) {
+ case await using:
+}
+for (await using;;);
+for (await using[x];;);
+
+await using
+x = a;
+
+await
+using
+x = a;
+
+await using
+[x] = a;
+
+await
+using
+[x] = a;
+
+// await using as keyword
+await using x = a;
+await using x = a, y = b;
+
+await using x
+= a;
+
+await using x
+= a, y = b;
+
+await using x = a
+ , y = b;
+
+await using x = a,
+ y = b;
+
+for (await using x of a);
+for (await using x = a;;);
+for (await using x = a, y = b;;);
+
+for (await using x
+= a;;);
+
+for (await using x
+= a, y = b;;);
+
+for (await using x = a
+ , y = b;;);
+
+for (await using x = a,
+ y = b;;);
+
+function f() {
+ await using x = a;
+}
+
+(() => {
+ await using x = a;
+})
+
+namespace N {
+ await using x = a;
+}
+
+class C {
+ constructor() {
+ await using x = a;
+ }
+ method() {
+ await using x = a;
+ }
+ get p() {
+ await using x = a;
+ }
+ set p(v) {
+ await using x = a;
+ }
+ static {
+ await using x = a;
+ }
+}
+
+// await using as expression, illegal syntax
+await using {x};
+await using {x: y};
+
+// await using as keyword, illegal syntax
+await using x;
+await using x, y;
+await using x, [y];
+await using x, {y};
+await using x, {y: z};
+await using x = a, y;
+await using x = a, [y];
+await using x = a, {y};
+await using x = a, {y: z};
+declare await using x;
+declare await using x = a;
+export await using x;
+export await using x = a;
diff --git a/tests/cases/using.ts b/tests/cases/using.ts
new file mode 100644
index 00000000..d9f9eb98
--- /dev/null
+++ b/tests/cases/using.ts
@@ -0,0 +1,201 @@
+// using as identifier
+using;
+using = a;
+using[x];
+using[x] = a;
+using.x;
+using.x = a;
+[using];
+[using] = a;
+({using});
+({using} = a);
+({using: x});
+({using: x} = a);
+({x: using});
+({x: using} = a);
+a = using;
+a = using[x];
+a = [using];
+a = {using};
+a = {using: x};
+a = {x: using};
+var using;
+var using = a;
+var [using];
+var [using] = a;
+let using;
+let using = a;
+let [using];
+let [using] = a;
+const using;
+const using = a;
+const [using];
+const [using] = a;
+function using() {}
+function f(using) {}
+function f(using = a) {}
+function f(using[x]) {}
+function f(using[x] = a) {}
+function f(a = using) {}
+using => {};
+(using) => {};
+([using]) => {};
+({using}) => {};
+({using: x}) => {};
+({x: using}) => {};
+() => using;
+async using => {};
+async (using) => {};
+class using {}
+class C extends using {}
+class C {}
+class C { using; }
+class C { static using; }
+class C { readonly using; }
+class C { declare using; }
+class C { abstract using; }
+class C { accessor using; }
+class C { static accessor using; }
+class C { readonly accessor using; }
+class C { using() {} }
+class C { static using() {} }
+class C { abstract using() }
+class C { get using() {} }
+class C { static get using() {} }
+class C { abstract get using(); }
+class C { set using() {} }
+class C { static set using(v) {} }
+class C { abstract set using(v); }
+class C { [using]; }
+class C { static [using]; }
+class C { readonly [using]; }
+class C { declare [using]; }
+class C { abstract [using]; }
+class C { accessor [using]; }
+class C { static accessor [using]; }
+class C { readonly accessor [using]; }
+class C { [using]() {} }
+class C { static [using]() {} }
+class C { abstract [using]() }
+class C { get [using]() {} }
+class C { static get [using]() {} }
+class C { abstract get [using](); }
+class C { set [using]() {} }
+class C { static set [using](v) {} }
+class C { abstract set [using](v); }
+namespace using {}
+namespace using.x {}
+interface using {}
+interface I { [using: string]: using; }
+type using = never;
+type X = never;
+enum using {}
+enum E { using };
+enum E { a = using };
+using: {};
+break using;
+continue using;
+switch (using) {
+ case using:
+}
+export { using };
+export { using as x };
+export { x as using };
+import using from "";
+import * as using from "";
+import { using } from "";
+import { using as x } from "";
+import { x as using } from "";
+for (using;;);
+for (using = a;;);
+for (using[x];;);
+for (using[x] = a;;);
+for (using in a);
+for (using of a);
+
+using
+x = a;
+
+using
+[x] = a;
+
+// using as keyword
+using x = a;
+using x = a, y = b;
+
+using x
+= a;
+
+using x
+= a, y = b;
+
+using x = a
+ , y = b;
+
+using x = a,
+ y = b;
+
+for (using x of a);
+for (using x = a;;);
+for (using x = a, y = b;;);
+
+for (using x
+= a;;);
+
+for (using x
+= a, y = b;;);
+
+for (using x = a
+ , y = b;;);
+
+for (using x = a,
+ y = b;;);
+
+function f() {
+ using x = a;
+}
+
+(() => {
+ using x = a;
+})
+
+namespace N {
+ using x = a;
+}
+
+class C {
+ constructor() {
+ using x = a;
+ }
+ method() {
+ using x = a;
+ }
+ get p() {
+ using x = a;
+ }
+ set p(v) {
+ using x = a;
+ }
+ static {
+ using x = a;
+ }
+}
+
+// using as identifier, illegal syntax
+using {x};
+using {x: y};
+
+// using as keyword, illegal syntax
+using x;
+using x, y;
+using x, [y];
+using x, {y};
+using x, {y: z};
+using x = a, y;
+using x = a, [y];
+using x = a, {y};
+using x = a, {y: z};
+declare using x;
+declare using x = a;
+export using x;
+export using x = a;