diff --git a/src/harness/client.ts b/src/harness/client.ts index 27411ba1f0c65..230517b599db9 100644 --- a/src/harness/client.ts +++ b/src/harness/client.ts @@ -747,7 +747,7 @@ namespace ts.server { return notImplemented(); } - getEncodedSemanticClassifications(_fileName: string, _span: TextSpan): Classifications { + getEncodedSemanticClassifications(_fileName: string, _span: TextSpan, _format?: SemanticClassificationFormat): Classifications { return notImplemented(); } diff --git a/src/harness/fourslashImpl.ts b/src/harness/fourslashImpl.ts index bd3bffb5642b6..f99eb118a0624 100644 --- a/src/harness/fourslashImpl.ts +++ b/src/harness/fourslashImpl.ts @@ -2492,7 +2492,49 @@ namespace FourSlash { Harness.IO.log(this.spanInfoToString(this.getNameOrDottedNameSpan(pos)!, "**")); } - private verifyClassifications(expected: { classificationType: string; text: string; textSpan?: TextSpan }[], actual: ts.ClassifiedSpan[], sourceFileText: string) { + private classificationToIdentifier(classification: number){ + + const tokenTypes: string[] = []; + tokenTypes[ts.classifier.v2020.TokenType.class] = "class"; + tokenTypes[ts.classifier.v2020.TokenType.enum] = "enum"; + tokenTypes[ts.classifier.v2020.TokenType.interface] = "interface"; + tokenTypes[ts.classifier.v2020.TokenType.namespace] = "namespace"; + tokenTypes[ts.classifier.v2020.TokenType.typeParameter] = "typeParameter"; + tokenTypes[ts.classifier.v2020.TokenType.type] = "type"; + tokenTypes[ts.classifier.v2020.TokenType.parameter] = "parameter"; + tokenTypes[ts.classifier.v2020.TokenType.variable] = "variable"; + tokenTypes[ts.classifier.v2020.TokenType.enumMember] = "enumMember"; + tokenTypes[ts.classifier.v2020.TokenType.property] = "property"; + tokenTypes[ts.classifier.v2020.TokenType.function] = "function"; + tokenTypes[ts.classifier.v2020.TokenType.member] = "member"; + + const tokenModifiers: string[] = []; + tokenModifiers[ts.classifier.v2020.TokenModifier.async] = "async"; + tokenModifiers[ts.classifier.v2020.TokenModifier.declaration] = "declaration"; + tokenModifiers[ts.classifier.v2020.TokenModifier.readonly] = "readonly"; + tokenModifiers[ts.classifier.v2020.TokenModifier.static] = "static"; + tokenModifiers[ts.classifier.v2020.TokenModifier.local] = "local"; + tokenModifiers[ts.classifier.v2020.TokenModifier.defaultLibrary] = "defaultLibrary"; + + + function getTokenTypeFromClassification(tsClassification: number): number | undefined { + if (tsClassification > ts.classifier.v2020.TokenEncodingConsts.modifierMask) { + return (tsClassification >> ts.classifier.v2020.TokenEncodingConsts.typeOffset) - 1; + } + return undefined; + } + + function getTokenModifierFromClassification(tsClassification: number) { + return tsClassification & ts.classifier.v2020.TokenEncodingConsts.modifierMask; + } + + const typeIdx = getTokenTypeFromClassification(classification) || 0; + const modSet = getTokenModifierFromClassification(classification); + + return [tokenTypes[typeIdx], ...tokenModifiers.filter((_, i) => modSet & 1 << i)].join("."); + } + + private verifyClassifications(expected: { classificationType: string | number, text?: string; textSpan?: TextSpan }[], actual: (ts.ClassifiedSpan | ts.ClassifiedSpan2020)[] , sourceFileText: string) { if (actual.length !== expected.length) { this.raiseError("verifyClassifications failed - expected total classifications to be " + expected.length + ", but was " + actual.length + @@ -2501,10 +2543,12 @@ namespace FourSlash { ts.zipWith(expected, actual, (expectedClassification, actualClassification) => { const expectedType = expectedClassification.classificationType; - if (expectedType !== actualClassification.classificationType) { + const actualType = typeof actualClassification.classificationType === "number" ? this.classificationToIdentifier(actualClassification.classificationType) : actualClassification.classificationType; + + if (expectedType !== actualType) { this.raiseError("verifyClassifications failed - expected classifications type to be " + expectedType + ", but was " + - actualClassification.classificationType + + actualType + jsonMismatchString()); } @@ -2555,10 +2599,30 @@ namespace FourSlash { } } - public verifySemanticClassifications(expected: { classificationType: string; text: string }[]) { + public replaceWithSemanticClassifications(format: ts.SemanticClassificationFormat.TwentyTwenty) { const actual = this.languageService.getSemanticClassifications(this.activeFile.fileName, - ts.createTextSpan(0, this.activeFile.content.length)); + ts.createTextSpan(0, this.activeFile.content.length), format); + const replacement = [`const c2 = classification("2020");`,`verify.semanticClassificationsAre("2020",`]; + for (const a of actual) { + const identifier = this.classificationToIdentifier(a.classificationType as number); + const text = this.activeFile.content.slice(a.textSpan.start, a.textSpan.start + a.textSpan.length); + replacement.push(` c2.semanticToken("${identifier}", "${text}"), `); + }; + replacement.push(");"); + throw new Error("You need to change the source code of fourslash test to use replaceWithSemanticClassifications"); + + // const fs = require("fs"); + // const testfilePath = this.originalInputFileName.slice(1); + // const testfile = fs.readFileSync(testfilePath, "utf8"); + // const newfile = testfile.replace("verify.replaceWithSemanticClassifications(\"2020\")", replacement.join("\n")); + // fs.writeFileSync(testfilePath, newfile); + } + + + public verifySemanticClassifications(format: ts.SemanticClassificationFormat, expected: { classificationType: string | number; text?: string }[]) { + const actual = this.languageService.getSemanticClassifications(this.activeFile.fileName, + ts.createTextSpan(0, this.activeFile.content.length), format); this.verifyClassifications(expected, actual, this.activeFile.content); } @@ -3859,7 +3923,7 @@ namespace FourSlash { const cancellation = new FourSlashInterface.Cancellation(state); // eslint-disable-next-line no-eval const f = eval(wrappedCode); - f(test, goTo, plugins, verify, edit, debug, format, cancellation, FourSlashInterface.Classification, FourSlashInterface.Completion, verifyOperationIsCancelled); + f(test, goTo, plugins, verify, edit, debug, format, cancellation, FourSlashInterface.classification, FourSlashInterface.Completion, verifyOperationIsCancelled); } catch (err) { // ensure 'source-map-support' is triggered while we still have the handler attached by accessing `error.stack`. diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts index 8c684d143aab7..096b1ea8e8dbc 100644 --- a/src/harness/fourslashInterfaceImpl.ts +++ b/src/harness/fourslashInterfaceImpl.ts @@ -524,8 +524,12 @@ namespace FourSlashInterface { /** * This method *requires* an ordered stream of classifications for a file, and spans are highly recommended. */ - public semanticClassificationsAre(...classifications: Classification[]) { - this.state.verifySemanticClassifications(classifications); + public semanticClassificationsAre(format: ts.SemanticClassificationFormat, ...classifications: Classification[]) { + this.state.verifySemanticClassifications(format, classifications); + } + + public replaceWithSemanticClassifications(format: ts.SemanticClassificationFormat.TwentyTwenty) { + this.state.replaceWithSemanticClassifications(format); } public renameInfoSucceeded(displayName?: string, fullDisplayName?: string, kind?: string, kindModifiers?: string, fileToRename?: string, expectedRange?: FourSlash.Range, options?: ts.RenameInfoOptions) { @@ -768,101 +772,127 @@ namespace FourSlashInterface { } } - interface Classification { + interface OlderClassification { classificationType: ts.ClassificationTypeNames; text: string; textSpan?: FourSlash.TextSpan; } - export namespace Classification { - export function comment(text: string, position?: number): Classification { + + // The VS Code LSP + interface ModernClassification { + classificationType: string; + text?: string; + textSpan?: FourSlash.TextSpan; + } + + type Classification = OlderClassification | ModernClassification; + + export function classification(format: ts.SemanticClassificationFormat) { + + function semanticToken(identifier: string, text: string, _position: number): Classification { + return { + classificationType: identifier, + text + }; + } + + if (format === ts.SemanticClassificationFormat.TwentyTwenty) { + return { + semanticToken + }; + } + + // Defaults to the previous semantic classifier factory functions + + function comment(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.comment, text, position); } - export function identifier(text: string, position?: number): Classification { + function identifier(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.identifier, text, position); } - export function keyword(text: string, position?: number): Classification { + function keyword(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.keyword, text, position); } - export function numericLiteral(text: string, position?: number): Classification { + function numericLiteral(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.numericLiteral, text, position); } - export function operator(text: string, position?: number): Classification { + function operator(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.operator, text, position); } - export function stringLiteral(text: string, position?: number): Classification { + function stringLiteral(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.stringLiteral, text, position); } - export function whiteSpace(text: string, position?: number): Classification { + function whiteSpace(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.whiteSpace, text, position); } - export function text(text: string, position?: number): Classification { + function text(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.text, text, position); } - export function punctuation(text: string, position?: number): Classification { + function punctuation(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.punctuation, text, position); } - export function docCommentTagName(text: string, position?: number): Classification { + function docCommentTagName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.docCommentTagName, text, position); } - export function className(text: string, position?: number): Classification { + function className(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.className, text, position); } - export function enumName(text: string, position?: number): Classification { + function enumName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.enumName, text, position); } - export function interfaceName(text: string, position?: number): Classification { + function interfaceName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.interfaceName, text, position); } - export function moduleName(text: string, position?: number): Classification { + function moduleName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.moduleName, text, position); } - export function typeParameterName(text: string, position?: number): Classification { + function typeParameterName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.typeParameterName, text, position); } - export function parameterName(text: string, position?: number): Classification { + function parameterName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.parameterName, text, position); } - export function typeAliasName(text: string, position?: number): Classification { + function typeAliasName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.typeAliasName, text, position); } - export function jsxOpenTagName(text: string, position?: number): Classification { + function jsxOpenTagName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.jsxOpenTagName, text, position); } - export function jsxCloseTagName(text: string, position?: number): Classification { + function jsxCloseTagName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.jsxCloseTagName, text, position); } - export function jsxSelfClosingTagName(text: string, position?: number): Classification { + function jsxSelfClosingTagName(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.jsxSelfClosingTagName, text, position); } - export function jsxAttribute(text: string, position?: number): Classification { + function jsxAttribute(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.jsxAttribute, text, position); } - export function jsxText(text: string, position?: number): Classification { + function jsxText(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.jsxText, text, position); } - export function jsxAttributeStringLiteralValue(text: string, position?: number): Classification { + function jsxAttributeStringLiteralValue(text: string, position?: number): Classification { return getClassification(ts.ClassificationTypeNames.jsxAttributeStringLiteralValue, text, position); } @@ -870,7 +900,35 @@ namespace FourSlashInterface { const textSpan = position === undefined ? undefined : { start: position, end: position + text.length }; return { classificationType, text, textSpan }; } + + return { + comment, + identifier, + keyword, + numericLiteral, + operator, + stringLiteral, + whiteSpace, + text, + punctuation, + docCommentTagName, + className, + enumName, + interfaceName, + moduleName, + typeParameterName, + parameterName, + typeAliasName, + jsxOpenTagName, + jsxCloseTagName, + jsxSelfClosingTagName, + jsxAttribute, + jsxText, + jsxAttributeStringLiteralValue, + getClassification + }; } + export namespace Completion { export import SortText = ts.Completions.SortText; export import CompletionSource = ts.Completions.CompletionSource; diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts index 69d7238cbec15..cc2f285fc5c8f 100644 --- a/src/harness/harnessLanguageService.ts +++ b/src/harness/harnessLanguageService.ts @@ -461,14 +461,15 @@ namespace Harness.LanguageService { getSyntacticClassifications(fileName: string, span: ts.TextSpan): ts.ClassifiedSpan[] { return unwrapJSONCallResult(this.shim.getSyntacticClassifications(fileName, span.start, span.length)); } - getSemanticClassifications(fileName: string, span: ts.TextSpan): ts.ClassifiedSpan[] { - return unwrapJSONCallResult(this.shim.getSemanticClassifications(fileName, span.start, span.length)); + getSemanticClassifications(fileName: string, span: ts.TextSpan, format?: ts.SemanticClassificationFormat): ts.ClassifiedSpan[] { + return unwrapJSONCallResult(this.shim.getSemanticClassifications(fileName, span.start, span.length, format)); } getEncodedSyntacticClassifications(fileName: string, span: ts.TextSpan): ts.Classifications { return unwrapJSONCallResult(this.shim.getEncodedSyntacticClassifications(fileName, span.start, span.length)); } - getEncodedSemanticClassifications(fileName: string, span: ts.TextSpan): ts.Classifications { - return unwrapJSONCallResult(this.shim.getEncodedSemanticClassifications(fileName, span.start, span.length)); + getEncodedSemanticClassifications(fileName: string, span: ts.TextSpan, format?: ts.SemanticClassificationFormat): ts.Classifications { + const responseFormat = format || ts.SemanticClassificationFormat.Original; + return unwrapJSONCallResult(this.shim.getEncodedSemanticClassifications(fileName, span.start, span.length, responseFormat)); } getCompletionsAtPosition(fileName: string, position: number, preferences: ts.UserPreferences | undefined): ts.CompletionInfo { return unwrapJSONCallResult(this.shim.getCompletionsAtPosition(fileName, position, preferences)); diff --git a/src/services/classifier2020.ts b/src/services/classifier2020.ts new file mode 100644 index 0000000000000..263d1ca89d2c1 --- /dev/null +++ b/src/services/classifier2020.ts @@ -0,0 +1,249 @@ +/** @internal */ +namespace ts.classifier.v2020 { + + export const enum TokenEncodingConsts { + typeOffset = 8, + modifierMask = (1 << typeOffset) - 1 + } + + export const enum TokenType { + class, enum, interface, namespace, typeParameter, type, parameter, variable, enumMember, property, function, member + } + + export const enum TokenModifier { + declaration, static, async, readonly, defaultLibrary, local + } + + /** This is mainly used internally for testing */ + export function getSemanticClassifications(program: Program, cancellationToken: CancellationToken, sourceFile: SourceFile, span: TextSpan): ClassifiedSpan2020[] { + const classifications = getEncodedSemanticClassifications(program, cancellationToken, sourceFile, span); + + Debug.assert(classifications.spans.length % 3 === 0); + const dense = classifications.spans; + const result: ClassifiedSpan2020[] = []; + for (let i = 0; i < dense.length; i += 3) { + result.push({ + textSpan: createTextSpan(dense[i], dense[i + 1]), + classificationType: dense[i + 2] + }); + } + + return result; + } + + export function getEncodedSemanticClassifications(program: Program, cancellationToken: CancellationToken, sourceFile: SourceFile, span: TextSpan): Classifications { + return { + spans: getSemanticTokens(program, sourceFile, span, cancellationToken), + endOfLineState: EndOfLineState.None + }; + } + + function getSemanticTokens(program: Program, sourceFile: SourceFile, span: TextSpan, cancellationToken: CancellationToken): number[] { + const resultTokens: number[] = []; + + const collector = (node: Node, typeIdx: number, modifierSet: number) => { + resultTokens.push(node.getStart(sourceFile), node.getWidth(sourceFile), ((typeIdx + 1) << TokenEncodingConsts.typeOffset) + modifierSet); + }; + + if (program && sourceFile) { + collectTokens(program, sourceFile, span, collector, cancellationToken); + } + return resultTokens; + } + + function collectTokens(program: Program, sourceFile: SourceFile, span: TextSpan, collector: (node: Node, tokenType: number, tokenModifier: number) => void, cancellationToken: CancellationToken) { + const typeChecker = program.getTypeChecker(); + + let inJSXElement = false; + + function visit(node: Node) { + switch(node.kind) { + case SyntaxKind.ModuleDeclaration: + case SyntaxKind.ClassDeclaration: + case SyntaxKind.InterfaceDeclaration: + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.ClassExpression: + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + cancellationToken.throwIfCancellationRequested(); + } + + if (!node || !textSpanIntersectsWith(span, node.pos, node.getFullWidth()) || node.getFullWidth() === 0) { + return; + } + const prevInJSXElement = inJSXElement; + if (isJsxElement(node) || isJsxSelfClosingElement(node)) { + inJSXElement = true; + } + if (isJsxExpression(node)) { + inJSXElement = false; + } + + if (isIdentifier(node) && !inJSXElement && !inImportClause(node)) { + let symbol = typeChecker.getSymbolAtLocation(node); + if (symbol) { + if (symbol.flags & SymbolFlags.Alias) { + symbol = typeChecker.getAliasedSymbol(symbol); + } + let typeIdx = classifySymbol(symbol, getMeaningFromLocation(node)); + if (typeIdx !== undefined) { + let modifierSet = 0; + if (node.parent) { + const parentIsDeclaration = (isBindingElement(node.parent) || tokenFromDeclarationMapping.get(node.parent.kind) === typeIdx); + if (parentIsDeclaration && (node.parent).name === node) { + modifierSet = 1 << TokenModifier.declaration; + } + } + + // property declaration in constructor + if (typeIdx === TokenType.parameter && isRightSideOfQualifiedNameOrPropertyAccess(node)) { + typeIdx = TokenType.property; + } + + typeIdx = reclassifyByType(typeChecker, node, typeIdx); + + const decl = symbol.valueDeclaration; + if (decl) { + const modifiers = getCombinedModifierFlags(decl); + const nodeFlags = getCombinedNodeFlags(decl); + if (modifiers & ModifierFlags.Static) { + modifierSet |= 1 << TokenModifier.static; + } + if (modifiers & ModifierFlags.Async) { + modifierSet |= 1 << TokenModifier.async; + } + if (typeIdx !== TokenType.class && typeIdx !== TokenType.interface) { + if ((modifiers & ModifierFlags.Readonly) || (nodeFlags & NodeFlags.Const) || (symbol.getFlags() & SymbolFlags.EnumMember)) { + modifierSet |= 1 << TokenModifier.readonly; + } + } + if ((typeIdx === TokenType.variable || typeIdx === TokenType.function) && isLocalDeclaration(decl, sourceFile)) { + modifierSet |= 1 << TokenModifier.local; + } + if (program.isSourceFileDefaultLibrary(decl.getSourceFile())) { + modifierSet |= 1 << TokenModifier.defaultLibrary; + } + } + else if (symbol.declarations && symbol.declarations.some(d => program.isSourceFileDefaultLibrary(d.getSourceFile()))) { + modifierSet |= 1 << TokenModifier.defaultLibrary; + } + + collector(node, typeIdx, modifierSet); + + } + } + } + forEachChild(node, visit); + + inJSXElement = prevInJSXElement; + } + visit(sourceFile); + } + + function classifySymbol(symbol: Symbol, meaning: SemanticMeaning): TokenType | undefined { + const flags = symbol.getFlags(); + if (flags & SymbolFlags.Class) { + return TokenType.class; + } + else if (flags & SymbolFlags.Enum) { + return TokenType.enum; + } + else if (flags & SymbolFlags.TypeAlias) { + return TokenType.type; + } + else if (flags & SymbolFlags.Interface) { + if (meaning & SemanticMeaning.Type) { + return TokenType.interface; + } + } + else if (flags & SymbolFlags.TypeParameter) { + return TokenType.typeParameter; + } + let decl = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0]; + if (decl && isBindingElement(decl)) { + decl = getDeclarationForBindingElement(decl); + } + return decl && tokenFromDeclarationMapping.get(decl.kind); + } + + function reclassifyByType(typeChecker: TypeChecker, node: Node, typeIdx: TokenType): TokenType { + // type based classifications + if (typeIdx === TokenType.variable || typeIdx === TokenType.property || typeIdx === TokenType.parameter) { + const type = typeChecker.getTypeAtLocation(node); + if (type) { + const test = (condition: (type: Type) => boolean) => { + return condition(type) || type.isUnion() && type.types.some(condition); + }; + if (typeIdx !== TokenType.parameter && test(t => t.getConstructSignatures().length > 0)) { + return TokenType.class; + } + if (test(t => t.getCallSignatures().length > 0) && !test(t => t.getProperties().length > 0) || isExpressionInCallExpression(node)) { + return typeIdx === TokenType.property ? TokenType.member : TokenType.function; + } + } + } + return typeIdx; + } + + function isLocalDeclaration(decl: Declaration, sourceFile: SourceFile): boolean { + if (isBindingElement(decl)) { + decl = getDeclarationForBindingElement(decl); + } + if (isVariableDeclaration(decl)) { + return (!isSourceFile(decl.parent.parent.parent) || isCatchClause(decl.parent)) && decl.getSourceFile() === sourceFile; + } + else if (isFunctionDeclaration(decl)) { + return !isSourceFile(decl.parent) && decl.getSourceFile() === sourceFile; + } + return false; + } + + function getDeclarationForBindingElement(element: BindingElement): VariableDeclaration | ParameterDeclaration { + while (true) { + if (isBindingElement(element.parent.parent)) { + element = element.parent.parent; + } + else { + return element.parent.parent; + } + } + } + + function inImportClause(node: Node): boolean { + const parent = node.parent; + return parent && (isImportClause(parent) || isImportSpecifier(parent) || isNamespaceImport(parent)); + } + + function isExpressionInCallExpression(node: Node): boolean { + while (isRightSideOfQualifiedNameOrPropertyAccess(node)) { + node = node.parent; + } + return isCallExpression(node.parent) && node.parent.expression === node; + } + + function isRightSideOfQualifiedNameOrPropertyAccess(node: Node): boolean { + return (isQualifiedName(node.parent) && node.parent.right === node) || (isPropertyAccessExpression(node.parent) && node.parent.name === node); + } + + const tokenFromDeclarationMapping = new Map([ + [SyntaxKind.VariableDeclaration, TokenType.variable], + [SyntaxKind.Parameter, TokenType.parameter], + [SyntaxKind.PropertyDeclaration, TokenType.property], + [SyntaxKind.ModuleDeclaration, TokenType.namespace], + [SyntaxKind.EnumDeclaration, TokenType.enum], + [SyntaxKind.EnumMember, TokenType.enumMember], + [SyntaxKind.ClassDeclaration, TokenType.class], + [SyntaxKind.MethodDeclaration, TokenType.member], + [SyntaxKind.FunctionDeclaration, TokenType.function], + [SyntaxKind.FunctionExpression, TokenType.function], + [SyntaxKind.MethodSignature, TokenType.member], + [SyntaxKind.GetAccessor, TokenType.property], + [SyntaxKind.SetAccessor, TokenType.property], + [SyntaxKind.PropertySignature, TokenType.property], + [SyntaxKind.InterfaceDeclaration, TokenType.interface], + [SyntaxKind.TypeAliasDeclaration, TokenType.type], + [SyntaxKind.TypeParameter, TokenType.typeParameter], + [SyntaxKind.PropertyAssignment, TokenType.property], + [SyntaxKind.ShorthandPropertyAssignment, TokenType.property] + ]); +} diff --git a/src/services/services.ts b/src/services/services.ts index b8300aba0c34c..c0e951ae7c1a4 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1827,22 +1827,37 @@ namespace ts { return kind === ScriptKind.TS || kind === ScriptKind.TSX; } - function getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[] { + function getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + function getSemanticClassifications(fileName: string, span: TextSpan, format?: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[] { if (!isTsOrTsxFile(fileName)) { // do not run semantic classification on non-ts-or-tsx files return []; } synchronizeHostData(); - return ts.getSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span); + + const responseFormat = format || SemanticClassificationFormat.Original; + if (responseFormat === SemanticClassificationFormat.TwentyTwenty) { + return classifier.v2020.getSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span); + } + else { + return ts.getSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span); + } } - function getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications { + function getEncodedSemanticClassifications(fileName: string, span: TextSpan, format?: SemanticClassificationFormat): Classifications { if (!isTsOrTsxFile(fileName)) { // do not run semantic classification on non-ts-or-tsx files return { spans: [], endOfLineState: EndOfLineState.None }; } synchronizeHostData(); - return ts.getEncodedSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span); + + const responseFormat = format || SemanticClassificationFormat.Original; + if (responseFormat === SemanticClassificationFormat.Original) { + return ts.getEncodedSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span); + } + else { + return classifier.v2020.getEncodedSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span); + } } function getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[] { diff --git a/src/services/shims.ts b/src/services/shims.ts index 8729ce6cc0bb6..14f6a61e7478f 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -145,9 +145,9 @@ namespace ts { getCompilerOptionsDiagnostics(): string; getSyntacticClassifications(fileName: string, start: number, length: number): string; - getSemanticClassifications(fileName: string, start: number, length: number): string; + getSemanticClassifications(fileName: string, start: number, length: number, format?: SemanticClassificationFormat): string; getEncodedSyntacticClassifications(fileName: string, start: number, length: number): string; - getEncodedSemanticClassifications(fileName: string, start: number, length: number): string; + getEncodedSemanticClassifications(fileName: string, start: number, length: number, format?: SemanticClassificationFormat): string; getCompletionsAtPosition(fileName: string, position: number, preferences: UserPreferences | undefined): string; getCompletionEntryDetails(fileName: string, position: number, entryName: string, formatOptions: string/*Services.FormatCodeOptions*/ | undefined, source: string | undefined, preferences: UserPreferences | undefined): string; diff --git a/src/services/tsconfig.json b/src/services/tsconfig.json index 7bcfb701dfed1..8ec2432af6512 100644 --- a/src/services/tsconfig.json +++ b/src/services/tsconfig.json @@ -12,6 +12,7 @@ "types.ts", "utilities.ts", "classifier.ts", + "classifier2020.ts", "stringCompletions.ts", "completions.ts", "documentHighlights.ts", diff --git a/src/services/types.ts b/src/services/types.ts index 5acd9afbb80a8..7fb1166eb19c8 100644 --- a/src/services/types.ts +++ b/src/services/types.ts @@ -319,6 +319,11 @@ namespace ts { export type WithMetadata = T & { metadata?: unknown; }; + export const enum SemanticClassificationFormat { + Original = "original", + TwentyTwenty = "2020" + } + // // Public services of a language service instance associated // with a language service host instance @@ -382,13 +387,25 @@ namespace ts { /** @deprecated Use getEncodedSyntacticClassifications instead. */ getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getSyntacticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[]; /** @deprecated Use getEncodedSemanticClassifications instead. */ getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getSemanticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[]; - // Encoded as triples of [start, length, ClassificationType]. + /** Encoded as triples of [start, length, ClassificationType]. */ getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications; - getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications; + + /** + * Gets semantic highlights information for a particular file. Has two formats, an older + * version used by VS and a format used by VS Code. + * + * @param fileName The path to the file + * @param position A text span to return results within + * @param format Which format to use, defaults to "original" + * @returns a number array encoded as triples of [start, length, ClassificationType, ...]. + */ + getEncodedSemanticClassifications(fileName: string, span: TextSpan, format?: SemanticClassificationFormat): Classifications; /** * Gets completion entries at a particular position in a file. @@ -603,6 +620,11 @@ namespace ts { classificationType: ClassificationTypeNames; } + export interface ClassifiedSpan2020 { + textSpan: TextSpan; + classificationType: number; + } + /** * Navigation bar interface designed for visual studio's dual-column layout. * This does not form a proper tree. diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 389e66c9a336a..ea937a6e998f6 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -5355,6 +5355,10 @@ declare namespace ts { type WithMetadata = T & { metadata?: unknown; }; + enum SemanticClassificationFormat { + Original = "original", + TwentyTwenty = "2020" + } interface LanguageService { /** This is used as a part of restarting the language service. */ cleanupSemanticCache(): void; @@ -5406,10 +5410,22 @@ declare namespace ts { getCompilerOptionsDiagnostics(): Diagnostic[]; /** @deprecated Use getEncodedSyntacticClassifications instead. */ getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getSyntacticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[]; /** @deprecated Use getEncodedSemanticClassifications instead. */ getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getSemanticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[]; + /** Encoded as triples of [start, length, ClassificationType]. */ getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications; - getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications; + /** + * Gets semantic highlights information for a particular file. Has two formats, an older + * version used by VS and a format used by VS Code. + * + * @param fileName The path to the file + * @param position A text span to return results within + * @param format Which format to use, defaults to "original" + * @returns a number array encoded as triples of [start, length, ClassificationType, ...]. + */ + getEncodedSemanticClassifications(fileName: string, span: TextSpan, format?: SemanticClassificationFormat): Classifications; /** * Gets completion entries at a particular position in a file. * @@ -5568,6 +5584,10 @@ declare namespace ts { textSpan: TextSpan; classificationType: ClassificationTypeNames; } + interface ClassifiedSpan2020 { + textSpan: TextSpan; + classificationType: number; + } /** * Navigation bar interface designed for visual studio's dual-column layout. * This does not form a proper tree. diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 7b1a38a102b7c..971786b778223 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -5355,6 +5355,10 @@ declare namespace ts { type WithMetadata = T & { metadata?: unknown; }; + enum SemanticClassificationFormat { + Original = "original", + TwentyTwenty = "2020" + } interface LanguageService { /** This is used as a part of restarting the language service. */ cleanupSemanticCache(): void; @@ -5406,10 +5410,22 @@ declare namespace ts { getCompilerOptionsDiagnostics(): Diagnostic[]; /** @deprecated Use getEncodedSyntacticClassifications instead. */ getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getSyntacticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[]; /** @deprecated Use getEncodedSemanticClassifications instead. */ getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getSemanticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[]; + /** Encoded as triples of [start, length, ClassificationType]. */ getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications; - getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications; + /** + * Gets semantic highlights information for a particular file. Has two formats, an older + * version used by VS and a format used by VS Code. + * + * @param fileName The path to the file + * @param position A text span to return results within + * @param format Which format to use, defaults to "original" + * @returns a number array encoded as triples of [start, length, ClassificationType, ...]. + */ + getEncodedSemanticClassifications(fileName: string, span: TextSpan, format?: SemanticClassificationFormat): Classifications; /** * Gets completion entries at a particular position in a file. * @@ -5568,6 +5584,10 @@ declare namespace ts { textSpan: TextSpan; classificationType: ClassificationTypeNames; } + interface ClassifiedSpan2020 { + textSpan: TextSpan; + classificationType: number; + } /** * Navigation bar interface designed for visual studio's dual-column layout. * This does not form a proper tree. diff --git a/tests/cases/fourslash/classifyThisParameter.ts b/tests/cases/fourslash/classifyThisParameter.ts index 5e0c9a9d4b666..e28e5c2e67c9d 100644 --- a/tests/cases/fourslash/classifyThisParameter.ts +++ b/tests/cases/fourslash/classifyThisParameter.ts @@ -2,7 +2,7 @@ ////function f(this){} -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("function"), c.identifier("f"), diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts index 2b70dbcbf45ab..716589e32af8b 100644 --- a/tests/cases/fourslash/fourslash.ts +++ b/tests/cases/fourslash/fourslash.ts @@ -350,16 +350,18 @@ declare namespace FourSlashInterface { */ syntacticClassificationsAre(...classifications: { classificationType: string; - text: string; + text?: string; }[]): void; /** * This method *requires* an ordered stream of classifications for a file, and spans are highly recommended. */ - semanticClassificationsAre(...classifications: { - classificationType: string; - text: string; + semanticClassificationsAre(format: "original" | "2020", ...classifications: { + classificationType: string | number; + text?: string; textSpan?: TextSpan; }[]): void; + /** Edits the current testfile and replaces with the semantic classifications */ + replaceWithSemanticClassifications(format: "2020") renameInfoSucceeded(displayName?: string, fullDisplayName?: string, kind?: string, kindModifiers?: string, fileToRename?: string, range?: Range, allowRenameOfImportPath?: boolean): void; renameInfoFailed(message?: string, allowRenameOfImportPath?: boolean): void; renameLocations(startRanges: ArrayOrSingle, options: RenameLocationsOptions): void; @@ -461,118 +463,123 @@ declare namespace FourSlashInterface { resetCancelled(): void; setCancelled(numberOfCalls?: number): void; } - module classification { - function comment(text: string, position?: number): { + + interface ModernClassificationFactory { + semanticToken(identifier: string, name: string) + } + + interface ClassificationFactory { + comment(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function identifier(text: string, position?: number): { + identifier(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function keyword(text: string, position?: number): { + keyword(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function numericLiteral(text: string, position?: number): { + numericLiteral(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function operator(text: string, position?: number): { + operator(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function stringLiteral(text: string, position?: number): { + stringLiteral(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function whiteSpace(text: string, position?: number): { + whiteSpace(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function text(text: string, position?: number): { + text(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function punctuation(text: string, position?: number): { + punctuation(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function docCommentTagName(text: string, position?: number): { + docCommentTagName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function className(text: string, position?: number): { + className(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function enumName(text: string, position?: number): { + enumName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function interfaceName(text: string, position?: number): { + interfaceName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function moduleName(text: string, position?: number): { + moduleName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function typeParameterName(text: string, position?: number): { + typeParameterName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function parameterName(text: string, position?: number): { + parameterName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function typeAliasName(text: string, position?: number): { + typeAliasName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function jsxOpenTagName(text: string, position?: number): { + jsxOpenTagName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function jsxCloseTagName(text: string, position?: number): { + jsxCloseTagName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function jsxSelfClosingTagName(text: string, position?: number): { + jsxSelfClosingTagName(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function jsxAttribute(text: string, position?: number): { + jsxAttribute(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function jsxText(text: string, position?: number): { + jsxText(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; }; - function jsxAttributeStringLiteralValue(text: string, position?: number): { + jsxAttributeStringLiteralValue(text: string, position?: number): { classificationType: string; text: string; textSpan?: TextSpan; @@ -757,7 +764,8 @@ declare var edit: FourSlashInterface.edit; declare var debug: FourSlashInterface.debug; declare var format: FourSlashInterface.format; declare var cancellation: FourSlashInterface.cancellation; -declare var classification: typeof FourSlashInterface.classification; +declare function classification(format: "original"): FourSlashInterface.ClassificationFactory; +declare function classification(format: "2020"): FourSlashInterface.ModernClassificationFactory; declare namespace completion { type Entry = FourSlashInterface.ExpectedCompletionEntryObject; export const enum SortText { diff --git a/tests/cases/fourslash/incrementalJsDocAdjustsLengthsRight.ts b/tests/cases/fourslash/incrementalJsDocAdjustsLengthsRight.ts index 626a1e372588a..e4d438171a964 100644 --- a/tests/cases/fourslash/incrementalJsDocAdjustsLengthsRight.ts +++ b/tests/cases/fourslash/incrementalJsDocAdjustsLengthsRight.ts @@ -9,7 +9,7 @@ //// * @param {Number} wid/*1*/ goTo.marker('1'); edit.insert("th\n@"); -const c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/**\n * Pad `str` to `width`.\n *\n * "), c.punctuation("@"), diff --git a/tests/cases/fourslash/semanticClassification1.ts b/tests/cases/fourslash/semanticClassification1.ts index 4eb7f2a32edab..25f5557542a07 100644 --- a/tests/cases/fourslash/semanticClassification1.ts +++ b/tests/cases/fourslash/semanticClassification1.ts @@ -6,10 +6,20 @@ //// } //// interface /*2*/X extends /*3*/M./*4*/I { } -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.interfaceName("I", test.marker("1").position), c.interfaceName("X", test.marker("2").position), c.moduleName("M", test.marker("3").position), c.interfaceName("I", test.marker("4").position)); + +var c2 = classification("2020") +verify.semanticClassificationsAre("2020", + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("interface.declaration", "X"), + c2.semanticToken("namespace", "M"), + c2.semanticToken("interface", "I"), +) + diff --git a/tests/cases/fourslash/semanticClassification2.ts b/tests/cases/fourslash/semanticClassification2.ts index f7f6340e5bd6c..f250b7d690047 100644 --- a/tests/cases/fourslash/semanticClassification2.ts +++ b/tests/cases/fourslash/semanticClassification2.ts @@ -7,5 +7,14 @@ //// var Thing = 0; //// Thing.toExponential(); -var c = classification; -verify.semanticClassificationsAre(c.interfaceName("Thing", test.marker("0").position)); \ No newline at end of file +const c = classification("original"); +verify.semanticClassificationsAre("original", c.interfaceName("Thing", test.marker("0").position)); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("interface.declaration", "Thing"), + c2.semanticToken("member.declaration", "toExponential"), + c2.semanticToken("variable.declaration", "Thing"), + c2.semanticToken("variable", "Thing"), + c2.semanticToken("member.defaultLibrary", "toExponential") +); diff --git a/tests/cases/fourslash/semanticClassificationAlias.ts b/tests/cases/fourslash/semanticClassificationAlias.ts index 799674a211dae..eef56f91830d5 100644 --- a/tests/cases/fourslash/semanticClassificationAlias.ts +++ b/tests/cases/fourslash/semanticClassificationAlias.ts @@ -11,10 +11,18 @@ goTo.file("/b.ts"); const [m0, m1, m2, m3] = test.markers(); -const c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.typeAliasName("x", m0.position), c.className("y", m1.position), c.typeAliasName("x", m2.position), c.className("y", m3.position), ); + +const c2 = classification("2020"); + verify.semanticClassificationsAre("2020", + + c2.semanticToken("variable.declaration.readonly", "v"), + c2.semanticToken("type", "x"), + c2.semanticToken("class", "y"), +); diff --git a/tests/cases/fourslash/semanticClassificationClassExpression.ts b/tests/cases/fourslash/semanticClassificationClassExpression.ts index f067265df2994..eda79ce8f3d39 100644 --- a/tests/cases/fourslash/semanticClassificationClassExpression.ts +++ b/tests/cases/fourslash/semanticClassificationClassExpression.ts @@ -3,10 +3,19 @@ //// var x = class /*0*/C {} //// class /*1*/C {} //// class /*2*/D extends class /*3*/B{} { } -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.className("C", test.marker("0").position), c.className("C", test.marker("1").position), c.className("D", test.marker("2").position), c.className("B", test.marker("3").position) -); \ No newline at end of file +); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "x"), + c2.semanticToken("class", "C"), + c2.semanticToken("class.declaration", "C"), + c2.semanticToken("class.declaration", "D"), + c2.semanticToken("class", "B"), +); diff --git a/tests/cases/fourslash/semanticClassificationInTemplateExpressions.ts b/tests/cases/fourslash/semanticClassificationInTemplateExpressions.ts index 7ac8bec28207f..5866529de3da8 100644 --- a/tests/cases/fourslash/semanticClassificationInTemplateExpressions.ts +++ b/tests/cases/fourslash/semanticClassificationInTemplateExpressions.ts @@ -10,8 +10,8 @@ ////} ////`abcd${ /*3*/M./*4*/C.x + /*5*/M./*6*/E.E1}efg` -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.className("C", test.marker("1").position), c.enumName("E", test.marker("2").position), @@ -19,3 +19,18 @@ verify.semanticClassificationsAre( c.className("C", test.marker("4").position), c.moduleName("M", test.marker("5").position), c.enumName("E", test.marker("6").position)); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("class.declaration", "C"), + c2.semanticToken("property.declaration.static", "x"), + c2.semanticToken("enum.declaration", "E"), + c2.semanticToken("enumMember.declaration.readonly", "E1"), + c2.semanticToken("namespace", "M"), + c2.semanticToken("class", "C"), + c2.semanticToken("property.static", "x"), + c2.semanticToken("namespace", "M"), + c2.semanticToken("enum", "E"), + c2.semanticToken("enumMember.readonly", "E1"), +); diff --git a/tests/cases/fourslash/semanticClassificationInstantiatedModuleWithVariableOfSameName1.ts b/tests/cases/fourslash/semanticClassificationInstantiatedModuleWithVariableOfSameName1.ts index 2061c218eac7a..ab5de2ba6f175 100644 --- a/tests/cases/fourslash/semanticClassificationInstantiatedModuleWithVariableOfSameName1.ts +++ b/tests/cases/fourslash/semanticClassificationInstantiatedModuleWithVariableOfSameName1.ts @@ -15,10 +15,26 @@ //// ////var x = /*5*/M; -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.interfaceName("I", test.marker("1").position), c.moduleName("M", test.marker("3").position), c.interfaceName("I", test.marker("4").position), c.moduleName("M", test.marker("5").position)); + + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("variable.declaration.local", "x"), + c2.semanticToken("variable.declaration", "M"), + c2.semanticToken("property.declaration", "foo"), + c2.semanticToken("property.declaration", "bar"), + c2.semanticToken("variable.declaration", "v"), + c2.semanticToken("namespace", "M"), + c2.semanticToken("interface", "I"), + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("namespace", "M"), +); diff --git a/tests/cases/fourslash/semanticClassificationInstantiatedModuleWithVariableOfSameName2.ts b/tests/cases/fourslash/semanticClassificationInstantiatedModuleWithVariableOfSameName2.ts index f1f4fa8e67014..5f9de7227d9b3 100644 --- a/tests/cases/fourslash/semanticClassificationInstantiatedModuleWithVariableOfSameName2.ts +++ b/tests/cases/fourslash/semanticClassificationInstantiatedModuleWithVariableOfSameName2.ts @@ -18,11 +18,27 @@ //// ////var x = /*6*/M; -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.interfaceName("I", test.marker("1").position), c.moduleName("M", test.marker("2").position), c.moduleName("M", test.marker("4").position), c.interfaceName("I", test.marker("5").position), c.moduleName("M", test.marker("6").position)); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("variable.declaration.local", "x"), + c2.semanticToken("variable.declaration", "M"), + c2.semanticToken("property.declaration", "foo"), + c2.semanticToken("property.declaration", "bar"), + c2.semanticToken("variable.declaration", "v"), + c2.semanticToken("namespace", "M"), + c2.semanticToken("interface", "I"), + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("namespace", "M"), +); diff --git a/tests/cases/fourslash/semanticClassificationJs.ts b/tests/cases/fourslash/semanticClassificationJs.ts index 8105202a23fed..69683d6669511 100644 --- a/tests/cases/fourslash/semanticClassificationJs.ts +++ b/tests/cases/fourslash/semanticClassificationJs.ts @@ -6,4 +6,6 @@ //// let x = 1; // no semantic classification in js file -verify.semanticClassificationsAre(); \ No newline at end of file +verify.semanticClassificationsAre("original", ); + + diff --git a/tests/cases/fourslash/semanticClassificationModules.ts b/tests/cases/fourslash/semanticClassificationModules.ts index 6992639e4c3a5..5a57251b3a599 100644 --- a/tests/cases/fourslash/semanticClassificationModules.ts +++ b/tests/cases/fourslash/semanticClassificationModules.ts @@ -9,11 +9,25 @@ ////var x: /*2*/M./*3*/I = /*4*/M.v; ////var y = /*5*/M; -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.interfaceName("I", test.marker("1").position), c.moduleName("M", test.marker("2").position), c.interfaceName("I", test.marker("3").position), c.moduleName("M", test.marker("4").position), - c.moduleName("M", test.marker("5").position)); \ No newline at end of file + c.moduleName("M", test.marker("5").position)); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("variable.declaration.local", "v"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("namespace", "M"), + c2.semanticToken("interface", "I"), + c2.semanticToken("namespace", "M"), + c2.semanticToken("variable.local", "v"), + c2.semanticToken("variable.declaration", "y"), + c2.semanticToken("namespace", "M"), +); diff --git a/tests/cases/fourslash/semanticClassificationUninstantiatedModuleWithVariableOfSameName1.ts b/tests/cases/fourslash/semanticClassificationUninstantiatedModuleWithVariableOfSameName1.ts index 6c98c8340c38f..6c1e24e2d94f0 100644 --- a/tests/cases/fourslash/semanticClassificationUninstantiatedModuleWithVariableOfSameName1.ts +++ b/tests/cases/fourslash/semanticClassificationUninstantiatedModuleWithVariableOfSameName1.ts @@ -8,7 +8,16 @@ //// ////var M = { I: 10 }; -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), - c.interfaceName("I", test.marker("1").position)); \ No newline at end of file + c.interfaceName("I", test.marker("1").position)); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable", "M"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("variable.declaration", "M"), + c2.semanticToken("property.declaration", "I"), +); + \ No newline at end of file diff --git a/tests/cases/fourslash/semanticClassificationUninstantiatedModuleWithVariableOfSameName2.ts b/tests/cases/fourslash/semanticClassificationUninstantiatedModuleWithVariableOfSameName2.ts index 419692b98ce7d..1566d333c4e37 100644 --- a/tests/cases/fourslash/semanticClassificationUninstantiatedModuleWithVariableOfSameName2.ts +++ b/tests/cases/fourslash/semanticClassificationUninstantiatedModuleWithVariableOfSameName2.ts @@ -14,9 +14,24 @@ //// ////var x = /*5*/M; -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.interfaceName("I", test.marker("1").position), c.moduleName("M", test.marker("3").position), c.interfaceName("I", test.marker("4").position)); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable", "M"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("variable.declaration", "M"), + c2.semanticToken("property.declaration", "foo"), + c2.semanticToken("property.declaration", "bar"), + c2.semanticToken("variable.declaration", "v"), + c2.semanticToken("variable", "M"), + c2.semanticToken("interface", "I"), + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("variable", "M"), +); + \ No newline at end of file diff --git a/tests/cases/fourslash/semanticClassificationWithUnionTypes.ts b/tests/cases/fourslash/semanticClassificationWithUnionTypes.ts index bc55c5d8253cc..257130392df1f 100644 --- a/tests/cases/fourslash/semanticClassificationWithUnionTypes.ts +++ b/tests/cases/fourslash/semanticClassificationWithUnionTypes.ts @@ -11,8 +11,8 @@ ////var M: /*4*/M./*5*/I | /*6*/I | /*7*/C; ////var I: typeof M | typeof /*8*/C; -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.interfaceName("I", test.marker("1").position), c.interfaceName("I", test.marker("2").position), @@ -21,4 +21,20 @@ verify.semanticClassificationsAre( c.interfaceName("I", test.marker("5").position), c.interfaceName("I", test.marker("6").position), c.className("C", test.marker("7").position), - c.className("C", test.marker("8").position)); \ No newline at end of file + c.className("C", test.marker("8").position)); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable", "M"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("class.declaration", "C"), + c2.semanticToken("variable.declaration", "M"), + c2.semanticToken("variable", "M"), + c2.semanticToken("interface", "I"), + c2.semanticToken("interface", "I"), + c2.semanticToken("class", "C"), + c2.semanticToken("class.declaration", "I"), + c2.semanticToken("variable", "M"), + c2.semanticToken("class", "C"), +); diff --git a/tests/cases/fourslash/semanticClassificationsCancellation1.ts b/tests/cases/fourslash/semanticClassificationsCancellation1.ts index 9381bef5e86ce..84a0dafe17681 100644 --- a/tests/cases/fourslash/semanticClassificationsCancellation1.ts +++ b/tests/cases/fourslash/semanticClassificationsCancellation1.ts @@ -5,11 +5,20 @@ ////module N { ////} -var c = classification; +const c = classification("original"); cancellation.setCancelled(1); -verifyOperationIsCancelled(() => verify.semanticClassificationsAre()); +verifyOperationIsCancelled(() => verify.semanticClassificationsAre("original", )); cancellation.resetCancelled(); -verify.semanticClassificationsAre( +verify.semanticClassificationsAre("original", c.moduleName("M"), c.moduleName("N")); + + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("namespace.declaration", "N"), +); + + \ No newline at end of file diff --git a/tests/cases/fourslash/semanticClassificatonTypeAlias.ts b/tests/cases/fourslash/semanticClassificatonTypeAlias.ts index 188a09afcbc76..01e390b33a85d 100644 --- a/tests/cases/fourslash/semanticClassificatonTypeAlias.ts +++ b/tests/cases/fourslash/semanticClassificatonTypeAlias.ts @@ -5,11 +5,24 @@ ////var y = {}; ////function f(x: /*3*/Alias): /*4*/Alias { return undefined; } -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.typeAliasName("Alias", test.marker("0").position), c.typeAliasName("Alias", test.marker("1").position), c.typeAliasName("Alias", test.marker("2").position), c.typeAliasName("Alias", test.marker("3").position), c.typeAliasName("Alias", test.marker("4").position) - ); \ No newline at end of file + ); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("type.declaration", "Alias"), + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("type", "Alias"), + c2.semanticToken("variable.declaration", "y"), + c2.semanticToken("type", "Alias"), + c2.semanticToken("function.declaration", "f"), + c2.semanticToken("parameter.declaration", "x"), + c2.semanticToken("type", "Alias"), + c2.semanticToken("type", "Alias"), +); diff --git a/tests/cases/fourslash/semanticModernClassificationCallableVariables.ts b/tests/cases/fourslash/semanticModernClassificationCallableVariables.ts new file mode 100644 index 0000000000000..c98204baf8c75 --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationCallableVariables.ts @@ -0,0 +1,31 @@ +//// class A { onEvent: () => void; } +//// const x = new A().onEvent; +//// const match = (s: any) => x(); +//// const other = match; +//// match({ other }); +//// interface B = { (): string; }; var b: B +//// var s: String; +//// var t: { (): string; foo: string}; + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "A"), + c2.semanticToken("member.declaration", "onEvent"), + c2.semanticToken("function.declaration.readonly", "x"), + c2.semanticToken("class", "A"), + c2.semanticToken("member", "onEvent"), + c2.semanticToken("function.declaration.readonly", "match"), + c2.semanticToken("parameter.declaration", "s"), + c2.semanticToken("function.readonly", "x"), + c2.semanticToken("function.declaration.readonly", "other"), + c2.semanticToken("function.readonly", "match"), + c2.semanticToken("function.readonly", "match"), + c2.semanticToken("member.declaration", "other"), + c2.semanticToken("interface.declaration", "B"), + c2.semanticToken("variable.declaration", "b"), + c2.semanticToken("interface", "B"), + c2.semanticToken("variable.declaration", "s"), + c2.semanticToken("interface.defaultLibrary", "String"), + c2.semanticToken("variable.declaration", "t"), + c2.semanticToken("property.declaration", "foo"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/semanticModernClassificationCallableVariables2.ts b/tests/cases/fourslash/semanticModernClassificationCallableVariables2.ts new file mode 100644 index 0000000000000..d108398c02327 --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationCallableVariables2.ts @@ -0,0 +1,25 @@ +//// import "node"; +//// var fs = require("fs") +//// require.resolve('react'); +//// require.resolve.paths; +//// interface LanguageMode { getFoldingRanges?: (d: string) => number[]; }; +//// function (mode: LanguageMode | undefined) { if (mode && mode.getFoldingRanges) { return mode.getFoldingRanges('a'); }}; +//// function b(a: () => void) { a(); }; + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "fs"), + c2.semanticToken("interface.declaration", "LanguageMode"), + c2.semanticToken("member.declaration", "getFoldingRanges"), + c2.semanticToken("parameter.declaration", "d"), + c2.semanticToken("parameter.declaration", "mode"), + c2.semanticToken("interface", "LanguageMode"), + c2.semanticToken("parameter", "mode"), + c2.semanticToken("parameter", "mode"), + c2.semanticToken("member", "getFoldingRanges"), + c2.semanticToken("parameter", "mode"), + c2.semanticToken("member", "getFoldingRanges"), + c2.semanticToken("function.declaration", "b"), + c2.semanticToken("function.declaration", "a"), + c2.semanticToken("function", "a"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/semanticModernClassificationClassProperties.ts b/tests/cases/fourslash/semanticModernClassificationClassProperties.ts new file mode 100644 index 0000000000000..e2c3318dc2e74 --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationClassProperties.ts @@ -0,0 +1,21 @@ +//// class A { +//// private y: number; +//// constructor(public x : number, _y : number) { this.y = _y; } +//// get z() : number { return this.x + this.y; } +//// set a(v: number) { } +//// } + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "A"), + c2.semanticToken("property.declaration", "y"), + c2.semanticToken("parameter.declaration", "x"), + c2.semanticToken("parameter.declaration", "_y"), + c2.semanticToken("property", "y"), + c2.semanticToken("parameter", "_y"), + c2.semanticToken("property.declaration", "z"), + c2.semanticToken("property", "x"), + c2.semanticToken("property", "y"), + c2.semanticToken("property.declaration", "a"), + c2.semanticToken("parameter.declaration", "v"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/semanticModernClassificationConstructorTypes.ts b/tests/cases/fourslash/semanticModernClassificationConstructorTypes.ts new file mode 100644 index 0000000000000..25ef45b29b628 --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationConstructorTypes.ts @@ -0,0 +1,13 @@ +//// Object.create(null); +//// const x = Promise.resolve(Number.MAX_VALUE); +//// if (x instanceof Promise) {} + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.defaultLibrary", "Object"), + c2.semanticToken("member.defaultLibrary", "create"), + c2.semanticToken("variable.declaration.readonly", "x"), + c2.semanticToken("class.defaultLibrary", "Number"), + c2.semanticToken("property.readonly.defaultLibrary", "MAX_VALUE"), + c2.semanticToken("variable.readonly", "x"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/semanticModernClassificationFunctions.ts b/tests/cases/fourslash/semanticModernClassificationFunctions.ts new file mode 100644 index 0000000000000..730fe9aad206c --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationFunctions.ts @@ -0,0 +1,19 @@ +//// function foo(p1) { +//// return foo(Math.abs(p1)) +//// } +//// `/${window.location}`.split("/").forEach(s => foo(s)); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("function.declaration", "foo"), + c2.semanticToken("parameter.declaration", "p1"), + c2.semanticToken("function", "foo"), + c2.semanticToken("variable.defaultLibrary", "Math"), + c2.semanticToken("member.defaultLibrary", "abs"), + c2.semanticToken("parameter", "p1"), + c2.semanticToken("member.defaultLibrary", "split"), + c2.semanticToken("member.defaultLibrary", "forEach"), + c2.semanticToken("parameter.declaration", "s"), + c2.semanticToken("function", "foo"), + c2.semanticToken("parameter", "s"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/semanticModernClassificationInterfaces.ts b/tests/cases/fourslash/semanticModernClassificationInterfaces.ts new file mode 100644 index 0000000000000..a2967fd213a59 --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationInterfaces.ts @@ -0,0 +1,21 @@ +//// interface Pos { x: number, y: number }; +//// const p = { x: 1, y: 2 } as Pos; +//// const foo = (o: Pos) => o.x + o.y; + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("interface.declaration", "Pos"), + c2.semanticToken("property.declaration", "x"), + c2.semanticToken("property.declaration", "y"), + c2.semanticToken("variable.declaration.readonly", "p"), + c2.semanticToken("property.declaration", "x"), + c2.semanticToken("property.declaration", "y"), + c2.semanticToken("interface", "Pos"), + c2.semanticToken("function.declaration.readonly", "foo"), + c2.semanticToken("parameter.declaration", "o"), + c2.semanticToken("interface", "Pos"), + c2.semanticToken("parameter", "o"), + c2.semanticToken("property", "x"), + c2.semanticToken("parameter", "o"), + c2.semanticToken("property", "y"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/semanticModernClassificationMembers.ts b/tests/cases/fourslash/semanticModernClassificationMembers.ts new file mode 100644 index 0000000000000..0492b24955f67 --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationMembers.ts @@ -0,0 +1,24 @@ +//// class A { +//// static x = 9; +//// f = 9; +//// async m() { return A.x + await this.m(); }; +//// get s() { return this.f; +//// static t() { return new A().f; }; +//// constructor() {} +//// } + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "A"), + c2.semanticToken("property.declaration.static", "x"), + c2.semanticToken("property.declaration", "f"), + c2.semanticToken("member.declaration.async", "m"), + c2.semanticToken("class", "A"), + c2.semanticToken("property.static", "x"), + c2.semanticToken("member.async", "m"), + c2.semanticToken("property.declaration", "s"), + c2.semanticToken("property", "f"), + c2.semanticToken("member.declaration.static", "t"), + c2.semanticToken("class", "A"), + c2.semanticToken("property", "f"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/semanticModernClassificationObjectProperties.ts b/tests/cases/fourslash/semanticModernClassificationObjectProperties.ts new file mode 100644 index 0000000000000..31dc8f30f10f4 --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationObjectProperties.ts @@ -0,0 +1,13 @@ +//// let x = 1, y = 1; +//// const a1 = { e: 1 }; +//// var a2 = { x }; + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("variable.declaration", "y"), + c2.semanticToken("variable.declaration.readonly", "a1"), + c2.semanticToken("property.declaration", "e"), + c2.semanticToken("variable.declaration", "a2"), + c2.semanticToken("property.declaration", "x"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/semanticModernClassificationVariables.ts b/tests/cases/fourslash/semanticModernClassificationVariables.ts new file mode 100644 index 0000000000000..6c4e9c1567187 --- /dev/null +++ b/tests/cases/fourslash/semanticModernClassificationVariables.ts @@ -0,0 +1,19 @@ +//// var x = 9, y1 = [x]; +//// try { +//// for (const s of y1) { x = s } +//// } catch (e) { +//// throw y1; +//// } + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("variable.declaration", "y1"), + c2.semanticToken("variable", "x"), + c2.semanticToken("variable.declaration.readonly.local", "s"), + c2.semanticToken("variable", "y1"), + c2.semanticToken("variable", "x"), + c2.semanticToken("variable.readonly.local", "s"), + c2.semanticToken("variable.declaration.local", "e"), + c2.semanticToken("variable", "y1"), +);; \ No newline at end of file diff --git a/tests/cases/fourslash/shims-pp/getSemanticClassifications.ts b/tests/cases/fourslash/shims-pp/getSemanticClassifications.ts index 4eb7f2a32edab..1bbc4eec21a3e 100644 --- a/tests/cases/fourslash/shims-pp/getSemanticClassifications.ts +++ b/tests/cases/fourslash/shims-pp/getSemanticClassifications.ts @@ -6,8 +6,8 @@ //// } //// interface /*2*/X extends /*3*/M./*4*/I { } -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.interfaceName("I", test.marker("1").position), c.interfaceName("X", test.marker("2").position), diff --git a/tests/cases/fourslash/shims-pp/getSyntacticClassifications.ts b/tests/cases/fourslash/shims-pp/getSyntacticClassifications.ts index 1dbe2944b8ae5..897d42cbea729 100644 --- a/tests/cases/fourslash/shims-pp/getSyntacticClassifications.ts +++ b/tests/cases/fourslash/shims-pp/getSyntacticClassifications.ts @@ -18,7 +18,7 @@ //// } //// } -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("// comment"), c.keyword("module"), c.moduleName("M"), c.punctuation("{"), @@ -32,4 +32,4 @@ verify.syntacticClassificationsAre( c.punctuation("}"), c.keyword("module"), c.moduleName("M1"), c.punctuation("."), c.moduleName("M2"), c.punctuation("{"), c.punctuation("}"), - c.punctuation("}")); \ No newline at end of file + c.punctuation("}")); diff --git a/tests/cases/fourslash/shims/getSemanticClassifications.ts b/tests/cases/fourslash/shims/getSemanticClassifications.ts index 4eb7f2a32edab..1bbc4eec21a3e 100644 --- a/tests/cases/fourslash/shims/getSemanticClassifications.ts +++ b/tests/cases/fourslash/shims/getSemanticClassifications.ts @@ -6,8 +6,8 @@ //// } //// interface /*2*/X extends /*3*/M./*4*/I { } -var c = classification; -verify.semanticClassificationsAre( +const c = classification("original"); +verify.semanticClassificationsAre("original", c.moduleName("M", test.marker("0").position), c.interfaceName("I", test.marker("1").position), c.interfaceName("X", test.marker("2").position), diff --git a/tests/cases/fourslash/shims/getSyntacticClassifications.ts b/tests/cases/fourslash/shims/getSyntacticClassifications.ts index 1dbe2944b8ae5..897d42cbea729 100644 --- a/tests/cases/fourslash/shims/getSyntacticClassifications.ts +++ b/tests/cases/fourslash/shims/getSyntacticClassifications.ts @@ -18,7 +18,7 @@ //// } //// } -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("// comment"), c.keyword("module"), c.moduleName("M"), c.punctuation("{"), @@ -32,4 +32,4 @@ verify.syntacticClassificationsAre( c.punctuation("}"), c.keyword("module"), c.moduleName("M1"), c.punctuation("."), c.moduleName("M2"), c.punctuation("{"), c.punctuation("}"), - c.punctuation("}")); \ No newline at end of file + c.punctuation("}")); diff --git a/tests/cases/fourslash/syntacticClassificationForJSDocTemplateTag.ts b/tests/cases/fourslash/syntacticClassificationForJSDocTemplateTag.ts index c3368207d2cc2..0f8169828b30d 100644 --- a/tests/cases/fourslash/syntacticClassificationForJSDocTemplateTag.ts +++ b/tests/cases/fourslash/syntacticClassificationForJSDocTemplateTag.ts @@ -4,7 +4,7 @@ ////function ident: T { ////} -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/** "), c.punctuation("@"), @@ -20,3 +20,10 @@ verify.syntacticClassificationsAre( c.identifier("T"), c.punctuation("{"), c.punctuation("}")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("function.declaration", "ident"), + c2.semanticToken("typeParameter.declaration", "T"), + c2.semanticToken("typeParameter", "T"), +); diff --git a/tests/cases/fourslash/syntacticClassificationWithErrors.ts b/tests/cases/fourslash/syntacticClassificationWithErrors.ts index 166a22a1a5127..d21f8f9955ba7 100644 --- a/tests/cases/fourslash/syntacticClassificationWithErrors.ts +++ b/tests/cases/fourslash/syntacticClassificationWithErrors.ts @@ -5,10 +5,17 @@ ////} ////c = -let c = classification +const c = classification("original") + verify.syntacticClassificationsAre( c.keyword("class"), c.className("A"), c.punctuation("{"), c.identifier("a"), c.punctuation(":"), c.punctuation("}"), c.identifier("c"), c.operator("=") - ); \ No newline at end of file + ); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "A"), + c2.semanticToken("property.declaration", "a"), +); diff --git a/tests/cases/fourslash/syntacticClassifications1.ts b/tests/cases/fourslash/syntacticClassifications1.ts index 1dbe2944b8ae5..23c1460dcff3a 100644 --- a/tests/cases/fourslash/syntacticClassifications1.ts +++ b/tests/cases/fourslash/syntacticClassifications1.ts @@ -18,7 +18,7 @@ //// } //// } -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("// comment"), c.keyword("module"), c.moduleName("M"), c.punctuation("{"), @@ -32,4 +32,18 @@ verify.syntacticClassificationsAre( c.punctuation("}"), c.keyword("module"), c.moduleName("M1"), c.punctuation("."), c.moduleName("M2"), c.punctuation("{"), c.punctuation("}"), - c.punctuation("}")); \ No newline at end of file + c.punctuation("}")); + + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("variable.declaration.local", "v"), + c2.semanticToken("variable.declaration.local", "s"), + c2.semanticToken("class.declaration", "C"), + c2.semanticToken("typeParameter.declaration", "T"), + c2.semanticToken("enum.declaration", "E"), + c2.semanticToken("interface.declaration", "I"), + c2.semanticToken("namespace.declaration", "M1"), + c2.semanticToken("namespace.declaration", "M2"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsCancellation1.ts b/tests/cases/fourslash/syntacticClassificationsCancellation1.ts index f15ce5f9984c8..9b483463bec84 100644 --- a/tests/cases/fourslash/syntacticClassificationsCancellation1.ts +++ b/tests/cases/fourslash/syntacticClassificationsCancellation1.ts @@ -5,7 +5,7 @@ ////module N { ////} -var c = classification; +const c = classification("original"); cancellation.setCancelled(1); verifyOperationIsCancelled(() => verify.syntacticClassificationsAre()); cancellation.resetCancelled(); @@ -19,3 +19,9 @@ verify.syntacticClassificationsAre( c.moduleName("N"), c.punctuation("{"), c.punctuation("}")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("namespace.declaration", "M"), + c2.semanticToken("namespace.declaration", "N"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsConflictDiff3Markers1.ts b/tests/cases/fourslash/syntacticClassificationsConflictDiff3Markers1.ts index 669705307a96a..b63271f096b0f 100644 --- a/tests/cases/fourslash/syntacticClassificationsConflictDiff3Markers1.ts +++ b/tests/cases/fourslash/syntacticClassificationsConflictDiff3Markers1.ts @@ -10,7 +10,7 @@ ////>>>>>>> Branch - a ////} -const c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("class"), c.className("C"), c.punctuation("{"), c.comment("<<<<<<< HEAD"), @@ -20,4 +20,10 @@ verify.syntacticClassificationsAre( c.comment("======="), c.identifier("v"), c.punctuation("="), c.numericLiteral("2"), c.punctuation(";"), c.comment(">>>>>>> Branch - a"), - c.punctuation("}")); \ No newline at end of file + c.punctuation("}")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "C"), + c2.semanticToken("property.declaration", "v"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsConflictDiff3Markers2.ts b/tests/cases/fourslash/syntacticClassificationsConflictDiff3Markers2.ts index 17144397184c6..c75bb2130f5b9 100644 --- a/tests/cases/fourslash/syntacticClassificationsConflictDiff3Markers2.ts +++ b/tests/cases/fourslash/syntacticClassificationsConflictDiff3Markers2.ts @@ -8,7 +8,7 @@ ////class D { } ////>>>>>>> Branch - a -const c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("<<<<<<< HEAD"), c.keyword("class"), c.className("C"), c.punctuation("{"), c.punctuation("}"), @@ -16,4 +16,9 @@ verify.syntacticClassificationsAre( c.keyword("class"), c.identifier("E"), c.punctuation("{"), c.punctuation("}"), c.comment("======="), c.keyword("class"), c.identifier("D"), c.punctuation("{"), c.punctuation("}"), - c.comment(">>>>>>> Branch - a")); \ No newline at end of file + c.comment(">>>>>>> Branch - a")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "C"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsConflictMarkers1.ts b/tests/cases/fourslash/syntacticClassificationsConflictMarkers1.ts index 99db7443a4c73..54f40b2cc61ab 100644 --- a/tests/cases/fourslash/syntacticClassificationsConflictMarkers1.ts +++ b/tests/cases/fourslash/syntacticClassificationsConflictMarkers1.ts @@ -8,7 +8,7 @@ ////>>>>>>> Branch - a ////} -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("class"), c.className("C"), c.punctuation("{"), c.comment("<<<<<<< HEAD"), @@ -16,4 +16,10 @@ verify.syntacticClassificationsAre( c.comment("======="), c.identifier("v"), c.punctuation("="), c.numericLiteral("2"), c.punctuation(";"), c.comment(">>>>>>> Branch - a"), - c.punctuation("}")); \ No newline at end of file + c.punctuation("}")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "C"), + c2.semanticToken("property.declaration", "v"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsConflictMarkers2.ts b/tests/cases/fourslash/syntacticClassificationsConflictMarkers2.ts index 18363c0389e04..e787c832fa72a 100644 --- a/tests/cases/fourslash/syntacticClassificationsConflictMarkers2.ts +++ b/tests/cases/fourslash/syntacticClassificationsConflictMarkers2.ts @@ -6,10 +6,15 @@ ////class D { } ////>>>>>>> Branch - a -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("<<<<<<< HEAD"), c.keyword("class"), c.className("C"), c.punctuation("{"), c.punctuation("}"), c.comment("======="), c.keyword("class"), c.identifier("D"), c.punctuation("{"), c.punctuation("}"), - c.comment(">>>>>>> Branch - a")); \ No newline at end of file + c.comment(">>>>>>> Branch - a")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("class.declaration", "C"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsDocComment1.ts b/tests/cases/fourslash/syntacticClassificationsDocComment1.ts index 1ea3bf9684a61..5a0194e8c5ad2 100644 --- a/tests/cases/fourslash/syntacticClassificationsDocComment1.ts +++ b/tests/cases/fourslash/syntacticClassificationsDocComment1.ts @@ -3,7 +3,7 @@ //// /** @type {number} */ //// var v; -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/** "), c.punctuation("@"), @@ -15,3 +15,9 @@ verify.syntacticClassificationsAre( c.keyword("var"), c.identifier("v"), c.punctuation(";")); + + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "v"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsDocComment2.ts b/tests/cases/fourslash/syntacticClassificationsDocComment2.ts index 38dca4edcf20d..d0e3eeba83645 100644 --- a/tests/cases/fourslash/syntacticClassificationsDocComment2.ts +++ b/tests/cases/fourslash/syntacticClassificationsDocComment2.ts @@ -4,7 +4,7 @@ //// var v; -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/** "), c.punctuation("@"), @@ -24,3 +24,8 @@ verify.syntacticClassificationsAre( c.keyword("var"), c.identifier("v"), c.punctuation(";")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "v"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsDocComment3.ts b/tests/cases/fourslash/syntacticClassificationsDocComment3.ts index d7996fbbc54e5..94009e799224b 100644 --- a/tests/cases/fourslash/syntacticClassificationsDocComment3.ts +++ b/tests/cases/fourslash/syntacticClassificationsDocComment3.ts @@ -3,7 +3,7 @@ //// /** @param foo { number /* } */ //// var v; -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/** "), c.punctuation("@"), @@ -17,3 +17,9 @@ verify.syntacticClassificationsAre( c.keyword("var"), c.identifier("v"), c.punctuation(";")); + + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "v"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsDocComment4.ts b/tests/cases/fourslash/syntacticClassificationsDocComment4.ts index d8ac2f12d8b32..ee8eaa933635c 100644 --- a/tests/cases/fourslash/syntacticClassificationsDocComment4.ts +++ b/tests/cases/fourslash/syntacticClassificationsDocComment4.ts @@ -3,7 +3,7 @@ //// /** @param {number} p1 */ //// function foo(p1) {} -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/** "), c.punctuation("@"), @@ -22,3 +22,9 @@ verify.syntacticClassificationsAre( c.punctuation(")"), c.punctuation("{"), c.punctuation("}")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("function.declaration", "foo"), + c2.semanticToken("parameter.declaration", "p1"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsForOfKeyword.ts b/tests/cases/fourslash/syntacticClassificationsForOfKeyword.ts index 22d7aa8ba946d..5a2354b380582 100644 --- a/tests/cases/fourslash/syntacticClassificationsForOfKeyword.ts +++ b/tests/cases/fourslash/syntacticClassificationsForOfKeyword.ts @@ -2,7 +2,7 @@ //// for (var of of of) { } -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("for"), c.punctuation("("), @@ -13,4 +13,10 @@ verify.syntacticClassificationsAre( c.punctuation(")"), c.punctuation("{"), c.punctuation("}") - ); \ No newline at end of file + ); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "of"), + c2.semanticToken("variable", "of"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsForOfKeyword2.ts b/tests/cases/fourslash/syntacticClassificationsForOfKeyword2.ts index 190663caa995e..1d8ba78579b93 100644 --- a/tests/cases/fourslash/syntacticClassificationsForOfKeyword2.ts +++ b/tests/cases/fourslash/syntacticClassificationsForOfKeyword2.ts @@ -2,7 +2,7 @@ //// for (var of in of) { } -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("for"), c.punctuation("("), @@ -13,4 +13,10 @@ verify.syntacticClassificationsAre( c.punctuation(")"), c.punctuation("{"), c.punctuation("}") - ); \ No newline at end of file + ); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "of"), + c2.semanticToken("variable", "of"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsForOfKeyword3.ts b/tests/cases/fourslash/syntacticClassificationsForOfKeyword3.ts index ef96c99fed45b..1e5f8481e5891 100644 --- a/tests/cases/fourslash/syntacticClassificationsForOfKeyword3.ts +++ b/tests/cases/fourslash/syntacticClassificationsForOfKeyword3.ts @@ -2,7 +2,7 @@ //// for (var of; of; of) { } -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("for"), c.punctuation("("), @@ -15,4 +15,11 @@ verify.syntacticClassificationsAre( c.punctuation(")"), c.punctuation("{"), c.punctuation("}") - ); \ No newline at end of file + ); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "of"), + c2.semanticToken("variable", "of"), + c2.semanticToken("variable", "of"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsFunctionWithComments.ts b/tests/cases/fourslash/syntacticClassificationsFunctionWithComments.ts index 05a5aaa173e0e..b9bde2d5df321 100644 --- a/tests/cases/fourslash/syntacticClassificationsFunctionWithComments.ts +++ b/tests/cases/fourslash/syntacticClassificationsFunctionWithComments.ts @@ -16,10 +16,20 @@ var firstCommentText = * There are many like it, but this one is mine.\n\ */"; -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment(firstCommentText), c.keyword("function"), c.identifier("myFunction"), c.punctuation("("), c.comment("/* x */"), c.parameterName("x"), c.punctuation(":"), c.keyword("any"), c.punctuation(")"), c.punctuation("{"), c.keyword("var"), c.identifier("y"), c.operator("="), c.identifier("x"), c.operator("?"), c.identifier("x"), c.operator("++"), c.operator(":"), c.operator("++"), c.identifier("x"), c.punctuation(";"), c.punctuation("}"), - c.comment("// end of file")); \ No newline at end of file + c.comment("// end of file")); + + const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("function.declaration", "myFunction"), + c2.semanticToken("parameter.declaration", "x"), + c2.semanticToken("variable.declaration.local", "y"), + c2.semanticToken("parameter", "x"), + c2.semanticToken("parameter", "x"), + c2.semanticToken("parameter", "x"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsJsx1.ts b/tests/cases/fourslash/syntacticClassificationsJsx1.ts index e9de07c759b7b..8e6bfc6462ec1 100644 --- a/tests/cases/fourslash/syntacticClassificationsJsx1.ts +++ b/tests/cases/fourslash/syntacticClassificationsJsx1.ts @@ -7,7 +7,7 @@ //// ////let y = -const c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("let"), c.identifier("x"), c.operator("="), c.punctuation("<"), @@ -24,4 +24,10 @@ verify.syntacticClassificationsAre( c.jsxSelfClosingTagName("element"), c.jsxAttribute("attr"), c.operator("="), c.jsxAttributeStringLiteralValue(`"123"`), c.punctuation("/"), c.punctuation(">") -) \ No newline at end of file +) + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("variable.declaration", "y"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsJsx2.ts b/tests/cases/fourslash/syntacticClassificationsJsx2.ts index 9110c6ce4b934..6c244ef4b6598 100644 --- a/tests/cases/fourslash/syntacticClassificationsJsx2.ts +++ b/tests/cases/fourslash/syntacticClassificationsJsx2.ts @@ -7,7 +7,7 @@ //// ////let y = -const c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("let"), c.identifier("x"), c.operator("="), c.punctuation("<"), @@ -24,4 +24,10 @@ verify.syntacticClassificationsAre( c.jsxSelfClosingTagName("element.name"), c.jsxAttribute("attr"), c.operator("="), c.jsxAttributeStringLiteralValue(`"123"`), c.punctuation("/"), c.punctuation(">") -) \ No newline at end of file +) + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("variable.declaration", "y"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsMergeConflictMarker1.ts b/tests/cases/fourslash/syntacticClassificationsMergeConflictMarker1.ts index b78a6f35982a6..49610740bc266 100644 --- a/tests/cases/fourslash/syntacticClassificationsMergeConflictMarker1.ts +++ b/tests/cases/fourslash/syntacticClassificationsMergeConflictMarker1.ts @@ -7,10 +7,14 @@ //// >>>>>>> Feature -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("<<<<<<< HEAD"), c.stringLiteral("\"AAAA\""), c.comment("======="), c.stringLiteral("\"BBBB\""), - c.comment(">>>>>>> Feature")); \ No newline at end of file + c.comment(">>>>>>> Feature")); + +const c2 = classification("2020"); + verify.semanticClassificationsAre("2020", +); diff --git a/tests/cases/fourslash/syntacticClassificationsObjectLiteral.ts b/tests/cases/fourslash/syntacticClassificationsObjectLiteral.ts index c5bab5181a3a7..6d5690b4d17bc 100644 --- a/tests/cases/fourslash/syntacticClassificationsObjectLiteral.ts +++ b/tests/cases/fourslash/syntacticClassificationsObjectLiteral.ts @@ -11,7 +11,7 @@ //// v: v += v, ////}; -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("var"), c.identifier("v"), c.operator("="), c.numericLiteral("10e0"), c.punctuation(";"), c.keyword("var"), c.identifier("x"), c.operator("="), c.punctuation("{"), @@ -22,4 +22,19 @@ verify.syntacticClassificationsAre( c.identifier("var"), c.punctuation(":"), c.numericLiteral("5"), c.punctuation(","), c.identifier("void"), c.punctuation(":"), c.keyword("void"), c.numericLiteral("0"), c.punctuation(","), c.identifier("v"), c.punctuation(":"), c.identifier("v"), c.operator("+="), c.identifier("v"), c.punctuation(","), - c.punctuation("}"), c.punctuation(";")); \ No newline at end of file + c.punctuation("}"), c.punctuation(";")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "v"), + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("property.declaration", "p1"), + c2.semanticToken("property.declaration", "p2"), + c2.semanticToken("property.declaration", "any"), + c2.semanticToken("property.declaration", "function"), + c2.semanticToken("property.declaration", "var"), + c2.semanticToken("property.declaration", "void"), + c2.semanticToken("property.declaration", "v"), + c2.semanticToken("variable", "v"), + c2.semanticToken("variable", "v"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsTemplates1.ts b/tests/cases/fourslash/syntacticClassificationsTemplates1.ts index 6c27aab3f40e8..f4864d56e0b21 100644 --- a/tests/cases/fourslash/syntacticClassificationsTemplates1.ts +++ b/tests/cases/fourslash/syntacticClassificationsTemplates1.ts @@ -6,10 +6,18 @@ //// p2: `goodbye ${0} cruel ${0} world`, ////}; -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("var"), c.identifier("v"), c.operator("="), c.numericLiteral("10e0"), c.punctuation(";"), c.keyword("var"), c.identifier("x"), c.operator("="), c.punctuation("{"), c.identifier("p1"), c.punctuation(":"), c.stringLiteral("`hello world`"), c.punctuation(","), c.identifier("p2"), c.punctuation(":"), c.stringLiteral("`goodbye ${"), c.numericLiteral("0"), c.stringLiteral("} cruel ${"), c.numericLiteral("0"), c.stringLiteral("} world`"), c.punctuation(","), - c.punctuation("}"), c.punctuation(";")); \ No newline at end of file + c.punctuation("}"), c.punctuation(";")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "v"), + c2.semanticToken("variable.declaration", "x"), + c2.semanticToken("property.declaration", "p1"), + c2.semanticToken("property.declaration", "p2"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsTemplates2.ts b/tests/cases/fourslash/syntacticClassificationsTemplates2.ts index 25bb64e78ba37..fc3b655d0257c 100644 --- a/tests/cases/fourslash/syntacticClassificationsTemplates2.ts +++ b/tests/cases/fourslash/syntacticClassificationsTemplates2.ts @@ -4,8 +4,13 @@ ////`goodbye "${ `hello world` }" ////and ${ `good${ " " }riddance` }`; -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.keyword("var"), c.identifier("tiredOfCanonicalExamples"), c.operator("="), c.stringLiteral("`goodbye \"${"), c.stringLiteral("`hello world`"), - c.stringLiteral("}\" \nand ${"), c.stringLiteral("`good${"), c.stringLiteral("\" \""), c.stringLiteral("}riddance`"), c.stringLiteral("}`"), c.punctuation(";")); \ No newline at end of file + c.stringLiteral("}\" \nand ${"), c.stringLiteral("`good${"), c.stringLiteral("\" \""), c.stringLiteral("}riddance`"), c.stringLiteral("}`"), c.punctuation(";")); + +const c2 = classification("2020"); +verify.semanticClassificationsAre("2020", + c2.semanticToken("variable.declaration", "tiredOfCanonicalExamples"), +); diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash1.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash1.ts index 13c27669ad5e6..daebae06adc73 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash1.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash1.ts @@ -2,7 +2,7 @@ //// /// -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/// "), c.punctuation("<"), @@ -12,4 +12,6 @@ verify.syntacticClassificationsAre( c.operator("="), c.jsxAttributeStringLiteralValue("\"./module.ts\""), c.comment(" "), - c.punctuation("/>")); \ No newline at end of file + c.punctuation("/>")); + + diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash10.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash10.ts index d1bb681b92ee9..25fd4cf0380cc 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash10.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash10.ts @@ -2,7 +2,7 @@ //// /// -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/// "), c.punctuation("<"), @@ -16,4 +16,4 @@ verify.syntacticClassificationsAre( c.operator("="), c.jsxAttributeStringLiteralValue("\"node\""), c.comment(" "), - c.punctuation("/>")); \ No newline at end of file + c.punctuation("/>")); diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash13.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash13.ts index 182b01f756017..877827e9753da 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash13.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash13.ts @@ -2,7 +2,7 @@ //// /// trailing -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/// "), c.punctuation("<"), @@ -13,4 +13,4 @@ verify.syntacticClassificationsAre( c.jsxAttributeStringLiteralValue("\"./module.ts\""), c.comment(" "), c.punctuation("/>"), - c.comment(" trailing")); \ No newline at end of file + c.comment(" trailing")); diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash14.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash14.ts index a7d16fea02ceb..197bc0d1579e7 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash14.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash14.ts @@ -2,6 +2,6 @@ //// /// nonElement -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( - c.comment("/// nonElement")); \ No newline at end of file + c.comment("/// nonElement")); diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash15.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash15.ts index 8ec5ebbea5d08..382fc3054a44a 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash15.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash15.ts @@ -3,7 +3,7 @@ //// /// //// /// -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/// "), c.punctuation("<"), @@ -22,4 +22,4 @@ verify.syntacticClassificationsAre( c.operator("="), c.jsxAttributeStringLiteralValue("\"./module2.ts\""), c.comment(" "), - c.punctuation("/>")); \ No newline at end of file + c.punctuation("/>")); diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash16.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash16.ts index 1dbee22cb594f..6315f74101341 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash16.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash16.ts @@ -3,7 +3,7 @@ //// /// //// 1 -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/// "), c.punctuation("<"), @@ -14,4 +14,4 @@ verify.syntacticClassificationsAre( c.jsxAttributeStringLiteralValue("\"./module.ts\""), c.comment(" "), c.punctuation("/>"), - c.numericLiteral("1")); \ No newline at end of file + c.numericLiteral("1")); diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash17.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash17.ts index b95cdd6b6c0f0..3b11eec9df11f 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash17.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash17.ts @@ -2,6 +2,6 @@ //// /// Text -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( - c.comment("/// Text")); \ No newline at end of file + c.comment("/// Text")); diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash18.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash18.ts index 148b17f6e4565..90dbd2b1d7678 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash18.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash18.ts @@ -2,6 +2,6 @@ //// /// Text -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( - c.comment("/// Text")); \ No newline at end of file + c.comment("/// Text")); diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash2.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash2.ts index 278d66dcb4a7f..618a5216537ba 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash2.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash2.ts @@ -2,7 +2,7 @@ //// /// -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("///"), c.punctuation("<"), @@ -13,4 +13,6 @@ verify.syntacticClassificationsAre( c.operator("="), c.comment(" "), c.jsxAttributeStringLiteralValue("\"./module.ts\""), - c.punctuation("/>")); \ No newline at end of file + c.punctuation("/>")); + + diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash3.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash3.ts index 11d3b2462be5b..1dea4b6968012 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash3.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash3.ts @@ -2,7 +2,7 @@ //// /// -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( c.comment("/// "), c.punctuation("<"), @@ -16,4 +16,6 @@ verify.syntacticClassificationsAre( c.operator("="), c.jsxAttributeStringLiteralValue("\"node\""), c.comment(" "), - c.punctuation("/>")); \ No newline at end of file + c.punctuation("/>")); + + diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash4.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash4.ts index d407bcee5032b..9d6267ecbcda1 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash4.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash4.ts @@ -2,6 +2,8 @@ //// /// < -var c = classification; +const c = classification("original"); verify.syntacticClassificationsAre( - c.comment("/// <")); // Don't classify until we recognize the element name \ No newline at end of file + c.comment("/// <")); // Don't classify until we recognize the element name + + diff --git a/tests/cases/fourslash/syntacticClassificationsTripleSlash5.ts b/tests/cases/fourslash/syntacticClassificationsTripleSlash5.ts index c6f1de38f2890..b3bab4bde6497 100644 --- a/tests/cases/fourslash/syntacticClassificationsTripleSlash5.ts +++ b/tests/cases/fourslash/syntacticClassificationsTripleSlash5.ts @@ -2,8 +2,10 @@ //// ///