perf(language-service): re-use token locations when available

Author: forivall

packages/graphql-language-service/src/interface/getDefinition.ts

@@ -25,7 +25,7 @@ import {
 
 import { Definition, FragmentInfo, Uri, ObjectTypeInfo } from '../types';
 
-import { locToRange, offsetToPosition, Range, Position } from '../utils';
+import { locToRange, locStartToPosition, Range, Position } from '../utils';
 // import { getTypeInfo } from './getAutocompleteSuggestions';
 
 export type DefinitionQueryResult = {
@@ -56,7 +56,7 @@ function getRange(text: string, node: ASTNode): Range {
 function getPosition(text: string, node: ASTNode): Position {
   const location = node.loc!;
   assert(location, 'Expected ASTNode to have a location.');
-  return offsetToPosition(text, location.start);
+  return locStartToPosition(text, location);
 }
 
 export async function getDefinitionQueryResultForNamedType(

packages/graphql-language-service/src/interface/getOutline.ts

@@ -41,7 +41,7 @@ import {
 } from 'graphql';
 import type { ASTReducer } from 'graphql/language/visitor';
 
-import { offsetToPosition } from '../utils';
+import { locToRange } from '../utils';
 
 const { INLINE_FRAGMENT } = Kind;
 
@@ -133,10 +133,11 @@ function outlineTreeConverter(docText: string): OutlineTreeConverterType {
     DocumentNode | SelectionSetNode | NameNode | InlineFragmentNode
   >;
   const meta = (node: ExclusiveUnion<MetaNode>): OutlineTreeResultMeta => {
+    const range = locToRange(docText, node.loc!);
     return {
       representativeName: node.name,
-      startPosition: offsetToPosition(docText, node.loc!.start),
-      endPosition: offsetToPosition(docText, node.loc!.end),
+      startPosition: range.start,
+      endPosition: range.end,
       kind: node.kind,
       children:
         node.selectionSet || node.fields || node.values || node.arguments || [],

packages/graphql-language-service/src/utils/Range.ts

@@ -66,8 +66,37 @@ export function offsetToPosition(text: string, loc: number): Position {
   return new Position(lines, loc - lastLineIndex - 1);
 }
 
+export function locStartToPosition(text: string, loc: Location) {
+  return loc.startToken?.start === loc.start
+    ? new Position(loc.startToken.line - 1, loc.startToken.column - 1)
+    : offsetToPosition(text, loc.start);
+}
+
+function locEndToPosition(text: string, loc: Location) {
+  if (loc.startToken?.start !== loc.start) {
+    return offsetToPosition(text, loc.end);
+  }
+  const EOL = '\n';
+  const buf = text.slice(loc.endToken.start, loc.endToken.end);
+  const lastLineIndex = buf.lastIndexOf(EOL);
+  if (lastLineIndex === -1) {
+    return new Position(
+      loc.endToken.line - 1,
+      loc.endToken.column + buf.length - 1,
+    );
+  }
+  const lines = buf.split(EOL).length - 1;
+  return new Position(
+    loc.endToken.line - 1 + lines,
+    loc.endToken.end - loc.endToken.start - lastLineIndex - 1,
+  );
+}
+
 export function locToRange(text: string, loc: Location): Range {
-  const start = offsetToPosition(text, loc.start);
-  const end = offsetToPosition(text, loc.end);
+  const start = locStartToPosition(text, loc);
+  const end =
+    loc.endToken?.end === loc.end
+      ? locEndToPosition(text, loc)
+      : offsetToPosition(text, loc.end);
   return new Range(start, end);
 }

packages/graphql-language-service/src/utils/__tests__/Range.test.ts

@@ -7,16 +7,18 @@
  *
  */
 
-import { Location } from 'graphql';
+import { Location, parse, getOperationAST, FieldNode } from 'graphql';
 import { Range, Position, offsetToPosition, locToRange } from '../Range';
 
 const text = `query test {
   name
 }`;
+const parsed = parse(text);
+const nameNode = getOperationAST(parsed)!.selectionSet.selections[0];
 
 const absRange: Location = {
   start: 15,
-  end: 18,
+  end: 19,
   // @ts-ignore
   startToken: null,
   // @ts-ignore
@@ -26,7 +28,7 @@ const absRange: Location = {
 }; // position of 'name' attribute in the test query
 
 const offsetRangeStart = new Position(1, 2);
-const offsetRangeEnd = new Position(1, 5);
+const offsetRangeEnd = new Position(1, 6);
 
 describe('Position', () => {
   it('constructs a IPosition object', () => {
@@ -87,4 +89,31 @@ describe('locToRange()', () => {
     expect(range.end.character).toEqual(offsetRangeEnd.character);
     expect(range.end.line).toEqual(offsetRangeEnd.line);
   });
+  it('returns the range for a location from a parsed node', () => {
+    const range = locToRange(text, nameNode.loc!);
+    expect(range.start.character).toEqual(offsetRangeStart.character);
+    expect(range.start.line).toEqual(offsetRangeStart.line);
+    expect(range.end.character).toEqual(offsetRangeEnd.character);
+    expect(range.end.line).toEqual(offsetRangeEnd.line);
+  });
+  it('returns the same range as offsetToPosition with multiline token', () => {
+    const blockText = `mutation test {
+      saveMarkdown(markdown: """
+        * block
+        * multiline
+        * string
+      """)
+    }`;
+    const blockParsed = parse(blockText);
+    const fieldNode = getOperationAST(blockParsed)!.selectionSet
+      .selections[0] as FieldNode;
+    const argumentNode = fieldNode.arguments![0];
+    const startPosition = offsetToPosition(blockText, argumentNode.loc!.start);
+    const endPosition = offsetToPosition(blockText, argumentNode.loc!.end);
+    const range = locToRange(blockText, argumentNode.loc!);
+    expect(range.start.character).toEqual(startPosition.character);
+    expect(range.start.line).toEqual(startPosition.line);
+    expect(range.end.character).toEqual(endPosition.character);
+    expect(range.end.line).toEqual(endPosition.line);
+  });
 });

packages/graphql-language-service/src/utils/index.ts

@@ -21,7 +21,13 @@ export {
 
 export { getASTNodeAtPosition, pointToOffset } from './getASTNodeAtPosition';
 
-export { Position, Range, locToRange, offsetToPosition } from './Range';
+export {
+  Position,
+  Range,
+  locStartToPosition,
+  locToRange,
+  offsetToPosition,
+} from './Range';
 
 export { validateWithCustomRules } from './validateWithCustomRules';