feat: add references

Author: felixfbecker

src/features/references.ts

@@ -5,7 +5,7 @@ import { Feature, scopeDocumentSelectorToRoot } from './feature'
 export const referencesFeature: Feature<typeof ReferencesRequest.type, 'referencesProvider'> = {
     requestType: ReferencesRequest.type,
     capabilityName: 'referencesProvider',
-    capabilityToRegisterOptions: capability => ({ documentSelector: null }),
+    capabilityToRegisterOptions: (capability, defaultSelector) => ({ documentSelector: defaultSelector }),
     register: ({ sourcegraph, connection, scopeRootUri, clientToServerURI, serverToClientURI, registerOptions }) =>
         sourcegraph.languages.registerReferenceProvider(
             scopeDocumentSelectorToRoot(registerOptions.documentSelector, scopeRootUri),
@@ -15,7 +15,10 @@ export const referencesFeature: Feature<typeof ReferencesRequest.type, 'referenc
                         textDocument: {
                             uri: clientToServerURI(new URL(textDocument.uri)).href,
                         },
-                        position,
+                        position: {
+                            line: position.line,
+                            character: position.character,
+                        },
                         context,
                     })
                     rewriteUris(result, serverToClientURI)

src/index.ts

@@ -169,6 +169,9 @@ export async function register({
             definition: {
                 dynamicRegistration: true,
             },
+            references: {
+                dynamicRegistration: true,
+            },
         },
         experimental: {
             progress: true,

src/test/integration.test.ts

@@ -6,8 +6,10 @@ import {
     Hover,
     InitializeParams,
     InitializeResult,
+    Location,
     MarkupKind,
     TextDocumentPositionParams,
+    ReferenceParams,
 } from 'vscode-languageserver-protocol'
 import { createMockSourcegraphAPI, stubTransport } from './stubs'
 
@@ -96,6 +98,87 @@ describe('register()', () => {
         await unsubscribed
         sinon.assert.calledOnce(createConnection.returnValues[0].unsubscribe)
     })
+    it('should register a references provider if the server reports the references capability', async () => {
+        const repoRoot = 'https://sourcegraph.test/repo@rev/-/raw/'
+        const server = {
+            initialize: sinon.spy(
+                (params: InitializeParams): InitializeResult => ({
+                    capabilities: {
+                        referencesProvider: true,
+                    },
+                })
+            ),
+            'textDocument/references': sinon.spy(
+                (params: ReferenceParams): Location[] => [
+                    {
+                        uri: new URL('bar.ts', repoRoot).href,
+                        range: {
+                            start: { line: 1, character: 2 },
+                            end: { line: 3, character: 4 },
+                        },
+                    },
+                ]
+            ),
+        }
+        const createConnection = stubTransport(server)
+
+        sourcegraph.workspace.textDocuments = [
+            {
+                uri: new URL('foo.ts', repoRoot).href,
+                languageId: 'typescript',
+                text: 'console.log("Hello world")',
+            },
+        ]
+        sourcegraph.workspace.roots = [{ uri: repoRoot }]
+
+        const documentSelector = [{ language: 'typescript' }]
+        await register({
+            sourcegraph: sourcegraph as any,
+            transport: createConnection,
+            documentSelector,
+            logger,
+        })
+
+        sinon.assert.calledWith(
+            server.initialize,
+            sinon.match({
+                capabilities: {
+                    textDocument: {
+                        references: {
+                            dynamicRegistration: true,
+                        },
+                    },
+                },
+            })
+        )
+
+        sinon.assert.calledOnce(sourcegraph.languages.registerReferenceProvider)
+
+        const [selector, provider] = sourcegraph.languages.registerReferenceProvider.args[0]
+        assert.deepStrictEqual(selector, [
+            {
+                language: 'typescript',
+                pattern: 'https://sourcegraph.test/repo@rev/-/raw/**',
+            },
+        ])
+        const result = await provider.provideReferences(
+            sourcegraph.workspace.textDocuments[0],
+            new sourcegraph.Position(0, 2),
+            { includeDeclaration: false }
+        )
+        sinon.assert.calledOnce(server['textDocument/references'])
+        sinon.assert.calledWith(server['textDocument/references'], {
+            textDocument: { uri: sourcegraph.workspace.textDocuments[0].uri },
+            position: { line: 0, character: 2 },
+            context: { includeDeclaration: false },
+        })
+        assert.deepStrictEqual(result, [
+            {
+                uri: new URL('bar.ts', repoRoot),
+                range: new sourcegraph.Range(new sourcegraph.Position(1, 2), new sourcegraph.Position(3, 4)),
+            },
+        ])
+    })
     it('should register a definition provider if the server reports the definition capability', async () => {
         const repoRoot = 'https://sourcegraph.test/repo@rev/-/raw/'
         const server = {

src/test/stubs.ts

@@ -68,10 +68,51 @@ export const createMockSourcegraphAPI = () => {
                     }
                 ) => new Subscription()
             ),
-            registerLocationProvider: sinon.spy(),
-            registerReferenceProvider: sinon.spy(),
-            registerTypeDefinitionProvider: sinon.spy(),
-            registerImplementationProvider: sinon.spy(),
+            registerLocationProvider: sinon.spy(
+                (
+                    selector: sourcegraph.DocumentSelector,
+                    provider: {
+                        provideLocations: (
+                            textDocument: sourcegraph.TextDocument,
+                            position: Position
+                        ) => Promise<sourcegraph.Definition>
+                    }
+                ) => new Subscription()
+            ),
+            registerReferenceProvider: sinon.spy(
+                (
+                    selector: sourcegraph.DocumentSelector,
+                    provider: {
+                        provideReferences: (
+                            textDocument: sourcegraph.TextDocument,
+                            position: Position,
+                            context: sourcegraph.ReferenceContext
+                        ) => Promise<sourcegraph.Location[]>
+                    }
+                ) => new Subscription()
+            ),
+            registerTypeDefinitionProvider: sinon.spy(
+                (
+                    selector: sourcegraph.DocumentSelector,
+                    provider: {
+                        provideTypeDefinition: (
+                            textDocument: sourcegraph.TextDocument,
+                            position: Position
+                        ) => Promise<sourcegraph.Definition>
+                    }
+                ) => new Subscription()
+            ),
+            registerImplementationProvider: sinon.spy(
+                (
+                    selector: sourcegraph.DocumentSelector,
+                    provider: {
+                        provideImplementation: (
+                            textDocument: sourcegraph.TextDocument,
+                            position: Position
+                        ) => Promise<sourcegraph.Definition>
+                    }
+                ) => new Subscription()
+            ),
         },
         app: {
             createDecorationType: () => ({ key: uniqueId('decorationType') }),