Merge pull request #10 from joshraphael/refactor

Refactor

Author: joshraphael

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Syntax highlighting to use upstream [rascript-syntax](https://github.com/joshraphael/rascript-syntax) repo
 - Bug involving incorrect comment bounds detected for hover, definition and completion data
+- Unify document parser to align with language server
 
 ### Removed
 

src/clients/shared/completionItemsProvider.ts

@@ -1,51 +1,23 @@
 import * as vscode from "vscode";
 import * as parser from "./parser";
-import { builtinFunctionDefinitions } from "./functionDefinitions";
 
 export function completionItemsProvider(
   document: vscode.TextDocument,
   position: vscode.Position
 ) {
-  let completionFunctions = [];
-  let completionVariables = [];
-  let completionClasses = [];
+  let parsedDocument = parser.parseDocument(document);
   let completionItems: vscode.CompletionItem[] = [];
-  for (let i = 0; i < builtinFunctionDefinitions.length; i++) {
-    let fn = builtinFunctionDefinitions[i];
-    completionFunctions.push(fn.key);
-  }
-  let text = document.getText();
-  let commentBounds = parser.getCommentBoundsList(document);
-  let classes = parser.getClassData(text, commentBounds);
-  let m: RegExpExecArray | null;
-  while ((m = parser.G_FUNCTION_DEFINITION.exec(text))) {
-    // dont parse if its in a comment
-    if (parser.inCommentBound(m.index, commentBounds)) {
-      continue;
-    }
-    completionFunctions.push(m[2]);
-  }
-  let functionSet: Set<string> = new Set(completionFunctions);
+  let functionSet: Set<string> = new Set(parsedDocument.completionFunctions);
   functionSet.forEach((fnName: string) => {
     completionItems.push(parser.newBuiltInFunction(fnName));
   });
-  while ((m = parser.G_VARIABLES.exec(text))) {
-    // dont parse if its in a comment
-    if (parser.inCommentBound(m.index, commentBounds)) {
-      continue;
-    }
-    completionVariables.push(m[1]);
-  }
-  let variableSet: Set<string> = new Set(completionVariables);
+  let variableSet: Set<string> = new Set(parsedDocument.completionVariables);
   variableSet.forEach((varName: string) => {
     completionItems.push(
       parser.newCompletion(varName, vscode.CompletionItemKind.Variable)
     );
   });
-  for (const [className, classScope] of classes) {
-    completionClasses.push(className);
-  }
-  let classSet: Set<string> = new Set(completionClasses);
+  let classSet: Set<string> = new Set(parsedDocument.completionClasses);
   classSet.forEach((className: string) => {
     completionItems.push(
       parser.newCompletion(className, vscode.CompletionItemKind.Class)

src/clients/shared/definitionProvider.ts

@@ -10,39 +10,13 @@ export function definitionProvider(
   let text = document.getText();
   const range = document.getWordRangeAtPosition(position);
   const word = document.getText(range);
+  let parsedDocument = parser.parseDocument(document);
   const origWordOffset = document.offsetAt(position);
-  let commentBounds = parser.getCommentBoundsList(document);
-  let classes = parser.getClassData(text, commentBounds);
-  let m: RegExpExecArray | null;
-  let functionDefinitions = new Map<string, models.ClassFunction[]>();
-  while ((m = parser.G_FUNCTION_DEFINITION.exec(text))) {
-    // dont parse if its in a comment
-    if (parser.inCommentBound(m.index, commentBounds)) {
-      continue;
-    }
-    let pos = document.positionAt(m.index);
-    let list = functionDefinitions.get(m[2]);
-    let a = m[3].split(",").map((s) => s.trim());
-    var args = a.filter(function (el) {
-      return el !== null && el !== "" && el !== undefined;
-    });
-    let item = parser.createClassFunction(
-      parser.detectClass(m.index, classes),
-      m[2],
-      pos,
-      ...args
-    );
-    if (list !== undefined) {
-      list.push(item);
-    } else {
-      functionDefinitions.set(m[2], [item]);
-    }
-  }
-  if (functionDefinitions.has(word)) {
+  if (parsedDocument.functionDefinitions.has(word)) {
     if (range !== undefined) {
       let endOffset = document.offsetAt(range.end);
       if (text[endOffset] !== "(") {
-        return null; // not a function
+        return null; // not a function (maybe comment, or just varaible named the same)
       }
     }
     let origOffset = document.offsetAt(position);
@@ -51,12 +25,12 @@ export function definitionProvider(
     }
     let offset = origOffset - 1;
     const [global, usingThis] = parser.getScope(document, origOffset);
-    let list = functionDefinitions.get(word) || [];
+    let list = parsedDocument.functionDefinitions.get(word) || [];
     let filteredList = list.filter(
       parser.classFilter(
         global,
         usingThis,
-        parser.detectClass(origWordOffset, classes)
+        parser.detectClass(origWordOffset, parsedDocument.classes)
       )
     );
     // can only link to one location, so anything that has multiple definitions wont work for code jumping

src/clients/shared/hoverProvider.ts

@@ -1,84 +1,11 @@
 import * as vscode from "vscode";
 import * as parser from "./parser";
-import * as models from "./models";
-import { builtinFunctionDefinitions } from "./functionDefinitions";
 
 export function hoverProvider(
   document: vscode.TextDocument,
   position: vscode.Position
 ) {
-  let words = new Map<string, models.HoverData[]>();
-  for (let i = 0; i < builtinFunctionDefinitions.length; i++) {
-    let fn = builtinFunctionDefinitions[i];
-    let comment = fn.commentDoc.join("\n");
-    let hover = parser.newHoverText(
-      fn.key,
-      -1,
-      parser.G_FUNTION,
-      "",
-      comment,
-      fn.url,
-      ...fn.args
-    );
-    let definitions = words.get(fn.key);
-    if (definitions !== undefined) {
-      definitions.push(hover);
-    } else {
-      words.set(fn.key, [hover]);
-    }
-  }
-  let text = document.getText();
-  let m: RegExpExecArray | null;
-  // get bounds of single line comments
-  let commentBounds = parser.getCommentBoundsList(document);
-  let classes = parser.getClassData(text, commentBounds);
-  for (const [className, classScope] of classes) {
-    let pos = document.positionAt(classScope.start);
-    let comment = parser.getCommentText(document, pos);
-    let hover = parser.newHoverText(
-      className,
-      classScope.start,
-      parser.G_CLASS,
-      "",
-      comment,
-      "",
-      ...classScope.constructorArgs
-    );
-    let definitions = words.get(className);
-    if (definitions !== undefined) {
-      definitions.push(hover);
-    } else {
-      words.set(className, [hover]);
-    }
-  }
-  while ((m = parser.G_FUNCTION_DEFINITION.exec(text))) {
-    // dont parse if its in a comment
-    if (parser.inCommentBound(m.index, commentBounds)) {
-      continue;
-    }
-    let className = parser.detectClass(m.index, classes);
-    let pos = document.positionAt(m.index);
-    let comment = parser.getCommentText(document, pos);
-    let a = m[3].split(",").map((s) => s.trim());
-    var args = a.filter(function (el) {
-      return el !== null && el !== "" && el !== undefined;
-    });
-    let hover = parser.newHoverText(
-      m[2],
-      m.index,
-      parser.G_FUNTION,
-      className,
-      comment,
-      "",
-      ...args
-    );
-    let definitions = words.get(m[2]);
-    if (definitions !== undefined) {
-      definitions.push(hover);
-    } else {
-      words.set(m[2], [hover]);
-    }
-  }
+  let parsedDocument = parser.parseDocument(document);
   const range = document.getWordRangeAtPosition(position);
   let startingPos = position;
   if (range?.start !== undefined) {
@@ -91,12 +18,12 @@ export function hoverProvider(
   const startingOffset = document.offsetAt(startingPos);
   const endingOffset = document.offsetAt(endingPos);
   const word = document.getText(range);
-  const hoverClass = parser.detectClass(startingOffset, classes);
+  const hoverClass = parser.detectClass(startingOffset, parsedDocument.classes);
   let offset = startingOffset - 1; // get character just before the function name position
 
   // Special case: this keyword should show the class hover info
   if (word === "this") {
-    let definitions = words.get(hoverClass);
+    let definitions = parsedDocument.hoverData.get(hoverClass);
     if (definitions !== undefined) {
       for (let i = 0; i < definitions.length; i++) {
         let definition = definitions[i];
@@ -108,7 +35,7 @@ export function hoverProvider(
   }
   const [global, usingThis] = parser.getScope(document, startingOffset);
 
-  let definitions = words.get(word);
+  let definitions = parsedDocument.hoverData.get(word);
   if (definitions !== undefined) {
     const [fn, cls] = parser.getWordType(
       document,

src/clients/shared/models.ts

@@ -35,3 +35,12 @@ export interface HoverData {
   args: string[];
   lines: string[];
 }
+
+export interface ParsedDocument {
+  classes: Map<string, ClassScope>;
+  functionDefinitions: Map<string, ClassFunction[]>;
+  hoverData: Map<string, HoverData[]>;
+  completionFunctions: string[];
+  completionVariables: string[];
+  completionClasses: string[];
+}

src/clients/shared/parser.ts

@@ -1,5 +1,6 @@
 import * as vscode from "vscode";
 import * as models from "./models";
+import { builtinFunctionDefinitions } from "./functionDefinitions";
 
 export const G_FUNCTION_DEFINITION =
   /(\bfunction\b)[\t ]*([a-zA-Z_][\w]*)[\t ]*\(([^\(\)]*)\)/g; // keep in sync with syntax file rascript.tmLanguage.json #function-definitions regex
@@ -348,7 +349,7 @@ export function detectClass(
 export function getClassData(
   text: string,
   commentBounds: models.CommentBounds[]
-) {
+): Map<string, models.ClassScope> {
   let classes = new Map<string, models.ClassScope>();
   let m: RegExpExecArray | null;
   while ((m = G_CLASS_DEFINITION.exec(text))) {
@@ -506,3 +507,130 @@ export function newHoverText(
     lines: lines,
   };
 }
+
+export function parseDocument(
+  document: vscode.TextDocument
+): models.ParsedDocument {
+  let text = document.getText();
+  let commentBounds = getCommentBoundsList(document);
+  let classes = getClassData(text, commentBounds);
+  let functionDefinitions = new Map<string, models.ClassFunction[]>();
+  let words = new Map<string, models.HoverData[]>(); // should be renamed to hoverData or something
+  let completionFunctions: string[] = [];
+  let completionVariables: string[] = [];
+  let completionClasses: string[] = [];
+  // Parse each build in function in the document
+  for (let i = 0; i < builtinFunctionDefinitions.length; i++) {
+    let fn = builtinFunctionDefinitions[i];
+
+    // Add hover data
+    let comment = fn.commentDoc.join("\n");
+    let hover = newHoverText(
+      fn.key,
+      -1,
+      G_FUNTION,
+      "",
+      comment,
+      fn.url,
+      ...fn.args
+    );
+    let definitions = words.get(fn.key);
+    if (definitions !== undefined) {
+      definitions.push(hover);
+    } else {
+      words.set(fn.key, [hover]);
+    }
+
+    // Add completion data
+    completionFunctions.push(fn.key);
+  }
+
+  // Parse each class in the document
+  for (const [className, classScope] of classes) {
+    // add hover info
+    let pos = document.positionAt(classScope.start);
+    let comment = getCommentText(document, pos);
+    let hover = newHoverText(
+      className,
+      classScope.start,
+      G_CLASS,
+      "",
+      comment,
+      "",
+      ...classScope.constructorArgs
+    );
+    let definitions = words.get(className);
+    if (definitions !== undefined) {
+      definitions.push(hover);
+    } else {
+      words.set(className, [hover]);
+    }
+
+    // add completion info
+    completionClasses.push(className);
+  }
+
+  // Parse each function in the document
+  let m: RegExpExecArray | null;
+  while ((m = G_FUNCTION_DEFINITION.exec(text))) {
+    // dont parse if its in a comment
+    if (inCommentBound(m.index, commentBounds)) {
+      continue;
+    }
+    let className = detectClass(m.index, classes);
+    let pos = document.positionAt(m.index);
+    let comment = getCommentText(document, pos);
+    let list = functionDefinitions.get(m[2]);
+    let a = m[3].split(",").map((s) => s.trim());
+    var args = a.filter(function (el) {
+      return el !== null && el !== "" && el !== undefined;
+    });
+
+    // add definition info
+    let item = createClassFunction(className, m[2], pos, ...args);
+    if (list !== undefined) {
+      list.push(item);
+    } else {
+      functionDefinitions.set(m[2], [item]);
+    }
+
+    // add hover info
+    let hover = newHoverText(
+      m[2],
+      m.index,
+      G_FUNTION,
+      className,
+      comment,
+      "",
+      ...args
+    );
+    let definitions = words.get(m[2]);
+    if (definitions !== undefined) {
+      definitions.push(hover);
+    } else {
+      words.set(m[2], [hover]);
+    }
+
+    // add completion info
+    completionFunctions.push(m[2]);
+  }
+
+  // Parse each variable in the document
+  while ((m = G_VARIABLES.exec(text))) {
+    // dont parse if its in a comment
+    if (inCommentBound(m.index, commentBounds)) {
+      continue;
+    }
+
+    // add completion info
+    completionVariables.push(m[1]);
+  }
+  return {
+    classes: classes,
+    functionDefinitions: functionDefinitions,
+    hoverData: words,
+    completionFunctions: completionFunctions,
+    completionVariables: completionVariables,
+    completionClasses: completionClasses,
+  };
+}