[#9] Update monaco editor and implement inlay hints for indexed funct…

…ion calls
Blazebit · Feb 28, 2022 · 76828f5 · 76828f5
1 parent abd052f
commit 76828f5
Show file tree

Hide file tree

Showing 24 changed files with 3,650 additions and 4,092 deletions.
diff --git a/editor/monaco/package-lock.json b/editor/monaco/package-lock.json
diff --git a/editor/monaco/package.json b/editor/monaco/package.json
@@ -14,29 +14,29 @@
   "homepage": "http://github.com/Blazebit/blaze-expression",
   "dependencies": {
     "antlr4ts": "^0.5.0-alpha.4",
-    "blaze-domain": "^2.0.4",
-    "monaco-editor": "^0.23.0"
+    "blaze-domain": "^3.0.0-Alpha4",
+    "monaco-editor": "^0.32.1"
   },
   "devDependencies": {
-    "@types/chai": "^4.2.11",
-    "@types/mocha": "^7.0.2",
+    "@types/chai": "^4.3.0",
+    "@types/mocha": "^9.1.0",
     "antlr4ts-cli": "^0.5.0-alpha.4",
-    "chai": "4.1.2",
-    "css-loader": "^3.5.3",
+    "chai": "4.3.6",
+    "css-loader": "^6.6.0",
     "esm": "^3.2.25",
-    "file-loader": "^6.0.0",
-    "jsdom": "^16.5.2",
+    "file-loader": "^6.2.0",
+    "jsdom": "^19.0.0",
     "jsdom-global": "^3.0.2",
-    "global-jsdom": "^8.0.0",
-    "mocha": "^7.2.0",
-    "mochapack": "^2.0.0",
-    "monaco-editor-webpack-plugin": "^3.0.1",
-    "style-loader": "^1.2.1",
-    "ts-loader": "^7.0.5",
-    "ts-node": "^8.10.2",
-    "typescript": "^3.9.3",
-    "webpack": "^4.39.2",
-    "webpack-cli": "^3.3.7"
+    "global-jsdom": "^8.4.0",
+    "mocha": "^9.2.1",
+    "mochapack": "^2.1.4",
+    "monaco-editor-webpack-plugin": "^7.0.1",
+    "style-loader": "^3.3.1",
+    "ts-loader": "^9.2.6",
+    "ts-node": "^10.5.0",
+    "typescript": "^4.5.5",
+    "webpack": "^5.69.1",
+    "webpack-cli": "^4.9.2"
   },
   "scripts": {
     "antlr4ts": "antlr4ts -o src/main/typescript/blaze-expression-predicate -visitor -Xexact-output-dir target/antlr4/BlazeExpressionLexer.g4 target/antlr4/BlazeExpressionParser.g4",

diff --git a/editor/monaco/pom.xml b/editor/monaco/pom.xml
@@ -94,8 +94,8 @@
                             <goal>install-node-and-npm</goal>
                         </goals>
                         <configuration>
-                            <nodeVersion>v12.18.0</nodeVersion>
-                            <npmVersion>6.14.4</npmVersion>
+                            <nodeVersion>v17.6.0</nodeVersion>
+                            <npmVersion>8.5.2</npmVersion>
                         </configuration>
                     </execution>
                     <execution>

diff --git a/editor/monaco/src/main/typescript/EditorFactory.ts b/editor/monaco/src/main/typescript/EditorFactory.ts
@@ -20,12 +20,13 @@ import {PredicateHoverProvider} from "./PredicateHoverProvider";
 import {PredicateSignatureHelpProvider} from "./PredicateSignatureHelpProvider";
 import {PredicateCompletionProvider} from "./PredicateCompletionProvider";
 import {SymbolTable} from "./SymbolTable";
-import * as monaco from "monaco-editor";
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api";
 import {ErrorEntry} from "./ErrorEntry";
 import {CollectorErrorListener} from "./CollectorErrorListener";
 import {BlazeExpressionErrorStrategy} from "./BlazeExpressionErrorStrategy";
 import {DomainType} from "blaze-domain";
 import {ExpressionException} from "./ExpressionException";
+import {PredicateInlayHintsProvider} from "./PredicateInlayHintsProvider";
 
 export let symbolTables: StringMap<SymbolTable> = {};
 
@@ -193,9 +194,11 @@ function _createEditor(monaco, templateMode: boolean, opts: BlazeExpressionConst
         monaco.languages.registerHoverProvider('predicate', new PredicateHoverProvider(false));
         monaco.languages.registerSignatureHelpProvider('predicate', new PredicateSignatureHelpProvider(false));
         monaco.languages.registerCompletionItemProvider('predicate', new PredicateCompletionProvider(false, predicateLiteralClass));
+        monaco.languages.registerInlayHintsProvider('predicate', new PredicateInlayHintsProvider(false));
         monaco.languages.registerHoverProvider('template', new PredicateHoverProvider(true));
         monaco.languages.registerSignatureHelpProvider('template', new PredicateSignatureHelpProvider(true));
         monaco.languages.registerCompletionItemProvider('template', new PredicateCompletionProvider(true, templateLiteralClass));
+        monaco.languages.registerInlayHintsProvider('template', new PredicateInlayHintsProvider(true));
     }
 
     let symbolTable;
@@ -224,7 +227,8 @@ function _createEditor(monaco, templateMode: boolean, opts: BlazeExpressionConst
         folding: false,
         scrollBeyondLastColumn: 0,
         scrollbar: { horizontal: 'hidden', vertical: 'hidden' },
-        find: { addExtraSpaceOnTop: false, autoFindInSelection: 'never', seedSearchStringFromSelection: false },
+        find: { addExtraSpaceOnTop: false, autoFindInSelection: 'never', seedSearchStringFromSelection: 'never' },
+        inlayHints: { enabled: true },
         minimap: { enabled: false },
         suggest: { showWords: false }
     };
@@ -242,7 +246,8 @@ function _createEditor(monaco, templateMode: boolean, opts: BlazeExpressionConst
         folding: false,
         scrollBeyondLastColumn: 0,
         scrollbar: {horizontal: 'hidden', vertical: 'hidden'},
-        find: {addExtraSpaceOnTop: false, autoFindInSelection: 'never', seedSearchStringFromSelection: false},
+        find: {addExtraSpaceOnTop: false, autoFindInSelection: 'never', seedSearchStringFromSelection: 'never'},
+        inlayHints: { enabled: true },
         minimap: {enabled: false},
         suggest: {showWords: false},
     };

diff --git a/editor/monaco/src/main/typescript/ExpressionService.ts b/editor/monaco/src/main/typescript/ExpressionService.ts
@@ -144,15 +144,19 @@ export class ExpressionService {
         return this.inTemplateExpressionContextChecker(input);
     }
 
-    parseTree(input: string): ParserRuleContext {
-        const lexer = this.lexerFactory(input);
+    parseTree(input: string, templateMode: boolean = false): ParserRuleContext {
+        const lexer = templateMode ? this.createTemplateLexer(input) : this.createLexer(input);
         lexer.removeErrorListeners();
         lexer.addErrorListener(new ConsoleErrorListener());
 
         const parser = this.parserFactory(lexer);
         parser.removeErrorListeners();
         parser.errorHandler = new BlazeExpressionErrorStrategy();
-        return this.parseRuleInvoker(parser);
+        if (templateMode) {
+            return this.parseTemplateRuleInvoker(parser);
+        } else {
+            return this.parseRuleInvoker(parser);
+        }
     }
 
     resolveType(input: string, symbolTable: SymbolTable) : DomainType {
@@ -239,8 +243,8 @@ export class ExpressionService {
         });
         registerIfAbsent("NumericLiteralResolver", function(): LiteralResolver {
             return { resolveLiteral(domainModel: DomainModel, kind: LiteralKind, value: boolean | string | EntityLiteral | EnumLiteral | CollectionLiteral): DomainType {
-                    if (isNaN(parseInt(value as string))) {
-                        return domainModel.types['Numeric'];
+                    if (kind == LiteralKind.NUMERIC) {
+                        return domainModel.getType('Numeric');
                     } else {
                         return domainModel.getType('Integer');
                     }

diff --git a/editor/monaco/src/main/typescript/LiteralKind.ts b/editor/monaco/src/main/typescript/LiteralKind.ts
@@ -25,6 +25,10 @@ export enum LiteralKind {
      * Boolean literal.
      */
     BOOLEAN,
+    /**
+     * Integer literal.
+     */
+    INTEGER,
     /**
      * Numeric literal.
      */

diff --git a/editor/monaco/src/main/typescript/PathResolvingProvider.ts b/editor/monaco/src/main/typescript/PathResolvingProvider.ts
@@ -15,7 +15,7 @@
  */
 
 import {PathResult} from "./PathResult";
-import * as monaco from "monaco-editor";
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api";
 import {Symbol} from "./Symbol";
 import {
     DomainFunction,

diff --git a/editor/monaco/src/main/typescript/PredicateCompletionProvider.ts b/editor/monaco/src/main/typescript/PredicateCompletionProvider.ts
@@ -15,7 +15,7 @@
  */
 
 import {PathResolvingProvider} from "./PathResolvingProvider";
-import * as monaco from "monaco-editor";
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api";
 import {CollectionDomainType, EntityDomainType, EnumDomainType} from "blaze-domain";
 import {symbolTables} from "./EditorFactory";
 import {SymbolTable} from "./SymbolTable";

diff --git a/editor/monaco/src/main/typescript/PredicateHoverProvider.ts b/editor/monaco/src/main/typescript/PredicateHoverProvider.ts
@@ -15,9 +15,8 @@
  */
 
 import {PathResolvingProvider} from "./PathResolvingProvider";
-import * as monaco from "monaco-editor";
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api";
 import {CollectionDomainType, EntityDomainType, EnumDomainType} from "blaze-domain";
-import {IMarkdownString} from "monaco-editor";
 import {symbolTables} from "./EditorFactory";
 
 /**
@@ -83,7 +82,7 @@ export class PredicateHoverProvider extends PathResolvingProvider implements mon
         }
         if (completionItem != null) {
             let docVal = "";
-            let doc: string | IMarkdownString = completionItem.documentation;
+            let doc: string | monaco.IMarkdownString = completionItem.documentation;
             if (doc != null) {
                 if (typeof doc === 'string' || doc instanceof String) {
                     docVal = "\n\n" + doc;