Adds the ability to test modern semantic classification via strings instead of numbers

Author: orta

src/compiler/types.ts

@@ -6498,6 +6498,11 @@ namespace ts {
         newLength: number;
     }
 
+    export const enum SemanticClassificationFormat {
+        Original = "orginal",
+        TwentyTwenty = "2020"
+    }
+
     /* @internal */
     export interface DiagnosticCollection {
         // Adds a diagnostic to this diagnostic collection.

src/harness/client.ts

@@ -739,7 +739,7 @@ namespace ts.server {
             return notImplemented();
         }
 
-        getEncodedSemanticClassifications(_fileName: string, _span: TextSpan, _format?: "original" | "2020"): Classifications {
+        getEncodedSemanticClassifications(_fileName: string, _span: TextSpan, _format?: SemanticClassificationFormat): Classifications {
             return notImplemented();
         }
 

src/harness/fourslashImpl.ts

@@ -2514,7 +2514,7 @@ namespace FourSlash {
             }
         }
 
-        public verifySemanticClassifications(format: "original" | "2020", expected: { classificationType: string | number; text?: string }[]) {
+        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);
 

src/harness/fourslashInterfaceImpl.ts

@@ -500,7 +500,7 @@ namespace FourSlashInterface {
         /**
          * This method *requires* an ordered stream of classifications for a file, and spans are highly recommended.
          */
-        public semanticClassificationsAre(format: "original" | "2020", ...classifications: Classification[]) {
+        public semanticClassificationsAre(format: ts.SemanticClassificationFormat, ...classifications: Classification[]) {
             this.state.verifySemanticClassifications(format, classifications);
         }
 
@@ -750,22 +750,73 @@ namespace FourSlashInterface {
         textSpan?: FourSlash.TextSpan;
     }
 
-    export function classification(format: "original" | "2020") {
-        function token(identifier: number, text: string, _position: number): Classification {
+
+    export function classification(format: ts.SemanticClassificationFormat) {
+
+        function semanticToken(identifier: string, text: string, _position: number): Classification {
+
+            const tokenTypes = {
+                class: ts.classifier.vscode.TokenType.class,
+                enum: ts.classifier.vscode.TokenType.enum,
+                interface: ts.classifier.vscode.TokenType.interface,
+                namespace: ts.classifier.vscode.TokenType.namespace,
+                typeParameter: ts.classifier.vscode.TokenType.typeParameter,
+                type: ts.classifier.vscode.TokenType.type,
+                parameter: ts.classifier.vscode.TokenType.parameter,
+                variable: ts.classifier.vscode.TokenType.variable,
+                enumMember: ts.classifier.vscode.TokenType.enumMember,
+                property: ts.classifier.vscode.TokenType.property,
+                function: ts.classifier.vscode.TokenType.function,
+                member: ts.classifier.vscode.TokenType.member
+            };
+
+            const tokenModifiers = {
+                async: ts.classifier.vscode.TokenModifier.async,
+                declaration: ts.classifier.vscode.TokenModifier.declaration,
+                readonly: ts.classifier.vscode.TokenModifier.readonly,
+                static: ts.classifier.vscode.TokenModifier.static,
+                local: ts.classifier.vscode.TokenModifier.local,
+                defaultLibrary: ts.classifier.vscode.TokenModifier.defaultLibrary,
+            };
+
+            function identifierToClassificationID(identifier: string): number {
+                const [tokenType, ...modifiers] = identifier.split(".");
+                // @ts-expect-error
+                const tokenValue = tokenTypes[tokenType];
+                if (tokenValue === undefined) {
+                    throw new Error(`Did not find ${tokenType} in tokenTypes for classifiers.`);
+                }
+
+                let classification = (tokenValue + 1) << 8;
+                ts.forEach(modifiers, (modifier) => {
+                    // @ts-expect-error
+                    const modifierValue = tokenModifiers[modifiers];
+                    if (tokenValue === undefined) {
+                        throw new Error(`Did not find ${modifier} in tokenModifiers for classifiers.`);
+                    }
+                    classification += modifierValue + 1;
+                    console.log("adding: ", modifierValue);
+                });
+
+                // debugger;
+
+                return classification;
+            }
+
             return {
-                classificationType: identifier,
-                // textSpan: { 
+                classificationType: identifierToClassificationID(identifier),
+                // textSpan: {
                 //     start: position,
                 //     end: -1
                 // },
                 text
-             }
+             };
         }
 
-        if (format === "2020") {
+        if (format === ts.SemanticClassificationFormat.TwentyTwenty) {
             return {
-                token
-            }
+                semanticToken
+            };
         }
 
         function comment(text: string, position?: number): Classification {
@@ -890,7 +941,7 @@ namespace FourSlashInterface {
             jsxText,
             jsxAttributeStringLiteralValue,
             getClassification
-        }
+        };
     }
 
     export namespace Completion {

src/harness/harnessLanguageService.ts

@@ -448,14 +448,14 @@ 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, format?: "original" | "2020"): ts.ClassifiedSpan[] {
+        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, format?: "original" | "2020"): ts.Classifications {
-            const responseFormat = format || "original";
+        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 {