Support for Wayfinder hover links to controllers

package.json

@@ -26,7 +26,9 @@
         "Other"
     ],
     "activationEvents": [
-        "onLanguage:php"
+        "onLanguage:php",
+        "onLanguage:typescript",
+        "onLanguage:typescriptreact"
     ],
     "main": "./dist/extension.js",
     "grammars": [

src/extension.ts

@@ -29,6 +29,7 @@ import {
     wrapSelectionCommand,
     wrapWithHelperCommands,
 } from "./commands/wrapWithHelper";
+import { WayfinderHoverProvider } from "./features/wayfinder";
 import { configAffected } from "./support/config";
 import { collectDebugInfo } from "./support/debug";
 import {
@@ -215,6 +216,10 @@ export async function activate(context: vscode.ExtensionContext) {
         ...hoverProviders.map((provider) =>
             vscode.languages.registerHoverProvider(LANGUAGES, provider),
         ),
+        vscode.languages.registerHoverProvider(
+            ["typescript", "typescriptreact"],
+            new WayfinderHoverProvider(),
+        ),
         // ...testRunnerCommands,
         // testController,
         vscode.languages.registerCodeActionsProvider(

src/features/wayfinder.ts

@@ -0,0 +1,107 @@
+import { HoverActions } from "@src/support/hoverAction";
+import { projectPath } from "@src/support/project";
+import { detect, languageService } from "@src/tsParser/tsParser";
+import { TsParsingResult } from "@src/types";
+import * as vscode from "vscode";
+
+const isInHoverRange = (
+    context: TsParsingResult.ContextValue,
+    offset: number,
+): boolean => offset >= context.start && offset <= context.end;
+
+const findContextAtOffset = (
+    contexts: TsParsingResult.ContextValue[],
+    offset: number,
+): TsParsingResult.ContextValue | undefined => {
+    for (const child of contexts) {
+        if (!isInHoverRange(child, offset)) {
+            continue;
+        }
+
+        return findContextAtOffset(child.children, offset) ?? child;
+    }
+
+    return undefined;
+};
+
+export class WayfinderHoverProvider implements vscode.HoverProvider {
+    provideHover(
+        document: vscode.TextDocument,
+        position: vscode.Position,
+    ): vscode.ProviderResult<vscode.Hover> {
+        const range = document.getWordRangeAtPosition(position);
+
+        if (!range) {
+            return null;
+        }
+
+        const contexts = detect(document);
+
+        if (!contexts) {
+            return null;
+        }
+
+        const foundContext = findContextAtOffset(
+            contexts,
+            document.offsetAt(position),
+        );
+
+        if (foundContext?.type !== "methodCall") {
+            return null;
+        }
+
+        if (
+            !foundContext.returnTypes.some(
+                (type) =>
+                    ["RouteDefinition", "RouteFormDefinition"].some((name) =>
+                        type.name.startsWith(name),
+                    ) && type.importPath?.endsWith("/wayfinder/index.ts"),
+            )
+        ) {
+            return null;
+        }
+
+        const quickInfo = languageService.getQuickInfoAtPosition(
+            document.fileName,
+            foundContext.start,
+        );
+
+        const controllerTag = quickInfo?.tags?.find(
+            (tag) =>
+                tag.name === "see" &&
+                (tag.text?.some((text) =>
+                    /Controller\.php:\d+$/.test(text.text),
+                ) ||
+                    false),
+        );
+
+        if (!controllerTag) {
+            return null;
+        }
+
+        const [controllerPath, lineAsString] = controllerTag.text
+            ?.map((text) => text.text.trim())
+            .join("")
+            .split(":") || [undefined, undefined];
+
+        if (!controllerPath) {
+            return null;
+        }
+
+        const line = lineAsString ? Number(lineAsString) : 0;
+
+        const hoverActions = new HoverActions([
+            {
+                title: "Go to controller",
+                command: "laravel.open",
+                arguments: [
+                    vscode.Uri.file(projectPath(controllerPath)),
+                    line,
+                    0,
+                ],
+            },
+        ]);
+
+        return new vscode.Hover(hoverActions.getAsMarkdownString(), range);
+    }
+}

src/support/hoverAction.ts

@@ -0,0 +1,32 @@
+import * as vscode from "vscode";
+
+export class HoverActions {
+    private readonly commands: vscode.Command[];
+
+    constructor(commands: vscode.Command[] = []) {
+        this.commands = commands;
+    }
+
+    public push(command: vscode.Command): this {
+        this.commands.push(command);
+
+        return this;
+    }
+
+    public getAsMarkdownString(): vscode.MarkdownString {
+        const string = this.commands
+            .map((command) => {
+                return [
+                    `[${command.title}](command:${command.command}?${encodeURIComponent(JSON.stringify(command.arguments))})`,
+                    `<span style="display: none;">${"&nbsp;".repeat(3)}</span>`,
+                ].join("");
+            })
+            .join("");
+
+        const markdownString = new vscode.MarkdownString(string);
+        markdownString.supportHtml = true;
+        markdownString.isTrusted = true;
+
+        return markdownString;
+    }
+}

src/tsParser/parsers/abstractParser.ts

@@ -0,0 +1,24 @@
+import { TsParsingResult } from "@src/types";
+import ts from "typescript";
+
+export abstract class NodeParser {
+    abstract parse(node: ts.Node): TsParsingResult.ContextValue;
+
+    protected getSymbolFlagValues(flags: ts.SymbolFlags): number[] {
+        const values: number[] = [];
+
+        for (const key in ts.SymbolFlags) {
+            const value = (ts.SymbolFlags as any)[key];
+
+            if (
+                typeof value === "number" &&
+                (flags & value) === value &&
+                value !== 0
+            ) {
+                values.push(value);
+            }
+        }
+
+        return values;
+    }
+}

src/tsParser/parsers/aliasExcludesParser.ts

@@ -0,0 +1,20 @@
+import { TsParsingResult } from "@src/types";
+import ts from "typescript";
+import { NodeParser } from "./abstractParser";
+import { MethodCallParser } from "./methodCallParser";
+
+export class AliasExcludesParser extends NodeParser {
+    private methodCallParser: MethodCallParser;
+
+    constructor(methodCallParser: MethodCallParser) {
+        super();
+
+        this.methodCallParser = methodCallParser;
+    }
+
+    public parse(
+        node: ts.Node,
+    ): TsParsingResult.MethodCall | TsParsingResult.Base {
+        return this.methodCallParser.parse(node);
+    }
+}

src/tsParser/parsers/assignmentParser.ts

@@ -0,0 +1,20 @@
+import { TsParsingResult } from "@src/types";
+import ts from "typescript";
+import { NodeParser } from "./abstractParser";
+import { MethodCallParser } from "./methodCallParser";
+
+export class AssignmentParser extends NodeParser {
+    private methodCallParser: MethodCallParser;
+
+    constructor(methodCallParser: MethodCallParser) {
+        super();
+
+        this.methodCallParser = methodCallParser;
+    }
+
+    public parse(
+        node: ts.Node,
+    ): TsParsingResult.MethodCall | TsParsingResult.Base {
+        return this.methodCallParser.parse(node);
+    }
+}

src/tsParser/parsers/baseParser.ts

@@ -0,0 +1,38 @@
+import { TsParsingResult } from "@src/types";
+import ts from "typescript";
+import { NodeParserFactory } from ".";
+import { NodeParser } from "./abstractParser";
+
+export class BaseParser extends NodeParser {
+    protected nodeParserFactory: NodeParserFactory;
+
+    protected typeChecker: ts.TypeChecker;
+
+    constructor(
+        nodeParserFactory: NodeParserFactory,
+        typeChecker: ts.TypeChecker,
+    ) {
+        super();
+
+        this.nodeParserFactory = nodeParserFactory;
+        this.typeChecker = typeChecker;
+    }
+
+    public parse(node: ts.Node): TsParsingResult.Base {
+        const children = this.nodeParserFactory.createContexts(
+            node.getChildren(),
+        );
+
+        const symbol = this.typeChecker.getSymbolAtLocation(node);
+
+        return {
+            type: "base",
+            symbolFlags: symbol?.getFlags()
+                ? this.getSymbolFlagValues(symbol.getFlags())
+                : [],
+            children: children,
+            start: node.getStart(),
+            end: node.getEnd(),
+        } as TsParsingResult.Base;
+    }
+}

src/tsParser/parsers/index.ts

@@ -0,0 +1,53 @@
+import { TsParsingResult } from "@src/types";
+import ts from "typescript";
+import { NodeParser } from "./abstractParser";
+import { AliasExcludesParser } from "./aliasExcludesParser";
+import { AssignmentParser } from "./assignmentParser";
+import { BaseParser } from "./baseParser";
+import { MethodCallParser } from "./methodCallParser";
+import { PropertyParser } from "./propertyParser";
+
+export class NodeParserFactory {
+    private typeChecker: ts.TypeChecker;
+
+    constructor(typeChecker: ts.TypeChecker) {
+        this.typeChecker = typeChecker;
+    }
+
+    public createContexts(
+        nodes: readonly ts.Node[],
+    ): TsParsingResult.ContextValue[] {
+        return nodes.map((node) => {
+            const nodeParser = this.createNodeParser(node);
+
+            return nodeParser.parse(node);
+        });
+    }
+
+    private createNodeParser(node: ts.Node): NodeParser {
+        const symbol = this.typeChecker.getSymbolAtLocation(node);
+
+        const flags = symbol?.getFlags();
+
+        if (flags) {
+            const methodCallParser = new MethodCallParser(
+                this,
+                this.typeChecker,
+            );
+
+            if (flags & ts.SymbolFlags.AliasExcludes) {
+                return new AliasExcludesParser(methodCallParser);
+            }
+
+            if (flags & ts.SymbolFlags.Property) {
+                return new PropertyParser(methodCallParser);
+            }
+
+            if (flags & ts.SymbolFlags.Assignment) {
+                return new AssignmentParser(methodCallParser);
+            }
+        }
+
+        return new BaseParser(this, this.typeChecker);
+    }
+}