@finos/legend-application 10.1.0 → 10.2.0

package/src/stores/PureLanguageSupport.ts

@@ -30,20 +30,55 @@ import {
 } from 'monaco-editor';
 import { EDITOR_LANGUAGE, EDITOR_THEME } from '../const.js';
 
+/**
+ * The postfix to be added to all token types, i.e. identifier.pure, number.pure, etc.
+ */
+const PURE_GRAMMAR_TOKEN_POSTFIX = '.pure';
+
+export enum PURE_GRAMMAR_TOKEN {
+  WHITESPACE = '',
+
+  KEYWORD = 'keyword',
+  IDENTIFIER = 'identifier',
+  OPERATOR = 'operator',
+  DELIMITER = 'delimiter',
+
+  PARSER = 'parser',
+  NUMBER = 'number',
+  DATE = 'date',
+  COLOR = 'color',
+  PACKAGE = 'package',
+  STRING = 'string',
+  COMMENT = 'comment',
+
+  LANGUAGE_STRUCT = 'language-struct',
+  MULTIPLICITY = 'multiplicity',
+  GENERICS = 'generics',
+  PROPERTY = 'property',
+  VARIABLE = 'variable',
+  TYPE = 'type',
+
+  INVALID = 'invalid',
+}
+
 const theme: monacoEditorAPI.IStandaloneThemeData = {
   base: 'vs-dark', // can also be vs-dark or hc-black
   inherit: true, // can also be false to completely replace the builtin rules
   colors: {},
   rules: [
     // NOTE: unfortunately, `monaco-editor` only accepts HEX values, not CSS variables
-    { token: 'package', foreground: '808080' },
-    { token: 'parser-marker', foreground: 'c586c0' },
-    { token: 'property', foreground: 'dcdcaa' },
-    { token: 'function', foreground: 'dcdcaa' },
-    { token: 'language-struct', foreground: 'c586c0' },
-    { token: 'multiplicity', foreground: '2d796b' },
-    { token: 'attribute', foreground: '9cdcfe' },
-    { token: 'cast', foreground: '569cd6' },
+    { token: PURE_GRAMMAR_TOKEN.IDENTIFIER, foreground: 'dcdcaa' },
+    { token: PURE_GRAMMAR_TOKEN.NUMBER, foreground: 'b5cea8' },
+    { token: PURE_GRAMMAR_TOKEN.DATE, foreground: 'b5cea8' },
+    { token: PURE_GRAMMAR_TOKEN.COLOR, foreground: 'b5cea8' },
+    { token: PURE_GRAMMAR_TOKEN.PACKAGE, foreground: '808080' },
+    { token: PURE_GRAMMAR_TOKEN.PARSER, foreground: 'c586c0' },
+    { token: PURE_GRAMMAR_TOKEN.LANGUAGE_STRUCT, foreground: 'c586c0' },
+    { token: PURE_GRAMMAR_TOKEN.MULTIPLICITY, foreground: '2d796b' },
+    { token: PURE_GRAMMAR_TOKEN.GENERICS, foreground: '2d796b' },
+    { token: PURE_GRAMMAR_TOKEN.PROPERTY, foreground: '9cdcfe' },
+    { token: PURE_GRAMMAR_TOKEN.VARIABLE, foreground: '4fc1ff' },
+    { token: PURE_GRAMMAR_TOKEN.TYPE, foreground: '3dc9b0' },
   ],
 };
 
@@ -73,6 +108,7 @@ const configuration: monacoLanguagesAPI.LanguageConfiguration = {
     { open: '"', close: '"' },
     { open: "'", close: "'" },
     { open: '<', close: '>' },
+    { open: '<<', close: '>>' },
   ],
   folding: {
     markers: {
@@ -103,7 +139,7 @@ const generateLanguageMonarch = (
   // TODO: add syntax highlighting for modules/plugins (come up with a plugin mechanism to do this).
   ({
     defaultToken: 'invalid',
-    tokenPostfix: '.pure',
+    tokenPostfix: PURE_GRAMMAR_TOKEN_POSTFIX,
 
     keywords: [
       ...extraKeywords,
@@ -118,6 +154,8 @@ const generateLanguageMonarch = (
       // native
       'let',
       'extends',
+      'true',
+      'false',
       'projects',
       // elements
       PURE_ELEMENT_NAME.CLASS,
@@ -182,9 +220,11 @@ const generateLanguageMonarch = (
       '#{',
       '}#',
       '@',
+      '<<',
+      '>>',
     ],
 
-    languageStructs: ['import', 'native', 'if', 'fold'],
+    languageStructs: ['import', 'native'],
 
     parsers: (
       [
@@ -204,6 +244,7 @@ const generateLanguageMonarch = (
       .map((parser) => `${PARSER_SECTION_MARKER}${parser}`),
 
     // common regular expressions to be used in tokenizer
+    identifier: /[a-zA-Z_$][\w$]*/,
     symbols: /[=><!~?:&|+\-*/^%#@]+/,
     escapes:
       /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
@@ -213,17 +254,25 @@ const generateLanguageMonarch = (
     hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
     multiplicity: /\[(?:\d+(?:\.\.(?:\d+|\*|))?|\*)\]/,
     package: /(?:[\w_]+::)+/,
+    generics: /<.+>/,
+    date: /%-?\d+(?:-\d+(?:-\d+(?:T(?:\d+(?::\d+(?::\d+(?:.\d+)?)?)?)(?:[+-][0-9]{4})?)))/,
+    time: /%\d+(?::\d+(?::\d+(?:.\d+)?)?)?/,
 
     tokenizer: {
       root: [
-        // packages
-        { include: '@package' },
+        // NOTE: since `monaco-editor` Monarch is only meant for tokenizing
+        // and the need to highlight Pure syntax is more than just token-based,
+        // but semantic/syntax-based we have to create these complex rules.
+        // the things to note here is these are not meant to match multilines
+        // and they must be placed before identifier rules since token matching
+        // is run in order
+        // See https://github.com/microsoft/monaco-editor/issues/316#issuecomment-273555698
+        // See https://github.com/microsoft/monaco-editor/issues/571#issuecomment-342555050
+        // See https://microsoft.github.io/monaco-editor/monarch.html
+        { include: '@pure' },
 
-        // properties
-        [/(\.)([\w_]+)/, ['delimiter', 'property']],
-
-        // functions
-        { include: '@function' },
+        { include: '@date' },
+        { include: '@color' },
 
         // parser markers
         [
@@ -231,20 +280,20 @@ const generateLanguageMonarch = (
           /^\s*###[\w]+/,
           {
             cases: {
-              '@parsers': 'parser-marker',
-              '@default': 'invalid',
+              '@parsers': PURE_GRAMMAR_TOKEN.PARSER,
+              '@default': PURE_GRAMMAR_TOKEN.INVALID,
             },
           },
         ],
 
         // identifiers and keywords
         [
-          /[a-zA-Z_$][\w$]*/,
+          /(@identifier)/,
           {
             cases: {
-              '@languageStructs': 'language-struct',
-              '@keywords': 'keyword.$0',
-              '@default': 'identifier',
+              '@languageStructs': PURE_GRAMMAR_TOKEN.LANGUAGE_STRUCT,
+              '@keywords': `${PURE_GRAMMAR_TOKEN.KEYWORD}.$0`,
+              '@default': PURE_GRAMMAR_TOKEN.IDENTIFIER,
             },
           },
         ],
@@ -259,97 +308,156 @@ const generateLanguageMonarch = (
           /@symbols/,
           {
             cases: {
-              '@operators': 'operator',
-              '@default': '',
+              '@operators': PURE_GRAMMAR_TOKEN.OPERATOR,
+              '@default': PURE_GRAMMAR_TOKEN.IDENTIFIER,
             },
           },
         ],
 
-        // numbers
         { include: '@number' },
 
         // delimiter: after number because of .\d floats
-        [/[;,.]/, 'delimiter'],
+        [/[;,.]/, PURE_GRAMMAR_TOKEN.DELIMITER],
 
         // strings
         // NOTE: including non-teminated string so as people type ', we can start showing them that they're working on a string
-        [/'([^'\\]|\\.)*$/, 'string.invalid'],
-        [/'/, 'string', '@string'],
+        [/'([^'\\]|\\.)*$/, `${PURE_GRAMMAR_TOKEN.STRING}.invalid`],
+        [/'/, PURE_GRAMMAR_TOKEN.STRING, '@string'],
 
-        // characters
         { include: '@characters' },
       ],
 
-      number: [
-        [/(@digits)[eE]([-+]?(@digits))?[fFdD]?/, 'number.float'],
-        [/(@digits)\.(@digits)([eE][-+]?(@digits))?[fFdD]?/, 'number.float'],
-        [/0[xX](@hexdigits)[Ll]?/, 'number.hex'],
-        [/0(@octaldigits)[Ll]?/, 'number.octal'],
-        [/0[bB](@binarydigits)[Ll]?/, 'number.binary'],
-        [/(@digits)[fFdD]/, 'number.float'],
-        [/(@digits)[lL]?/, 'number'],
-      ],
+      pure: [
+        // type
+        [/(@package\*)/, [PURE_GRAMMAR_TOKEN.PACKAGE]], // import path
+        [
+          /(@package?)(@identifier)(@generics?)(\s*)(@multiplicity)/,
+          [
+            PURE_GRAMMAR_TOKEN.PACKAGE,
+            PURE_GRAMMAR_TOKEN.TYPE,
+            PURE_GRAMMAR_TOKEN.GENERICS,
+            PURE_GRAMMAR_TOKEN.WHITESPACE,
+            PURE_GRAMMAR_TOKEN.MULTIPLICITY,
+          ],
+        ],
+        [
+          /(@package)(@identifier)(@generics?)/,
+          [
+            PURE_GRAMMAR_TOKEN.PACKAGE,
+            PURE_GRAMMAR_TOKEN.TYPE,
+            PURE_GRAMMAR_TOKEN.GENERICS,
+          ],
+        ],
 
-      function: [
-        [/(cast)(\()(@)/, ['function', '', 'cast']],
-        [/(->\s*)(cast)(\()(@)/, ['', 'function', '', 'cast']],
-        [/(->\s*)([\w_]+)(\s*\()/, ['', 'function', '']],
-        [/([\w_]+)(\s*\()/, ['function', '']],
-        [/(->\s*)([\w_]+)/, ['', 'function']],
-      ],
+        // special operators that uses type (e.g. constructor, cast)
+        [
+          /([@^])(?:\s*)(@package?)(@identifier)(@generics?)(@multiplicity?)/,
+          [
+            `${PURE_GRAMMAR_TOKEN.TYPE}.operator`,
+            PURE_GRAMMAR_TOKEN.PACKAGE,
+            PURE_GRAMMAR_TOKEN.TYPE,
+            PURE_GRAMMAR_TOKEN.GENERICS,
+            PURE_GRAMMAR_TOKEN.MULTIPLICITY,
+          ],
+        ],
+
+        // property / parameter
+        [
+          /(\.\s*)(@identifier)/,
+          [PURE_GRAMMAR_TOKEN.DELIMITER, PURE_GRAMMAR_TOKEN.PROPERTY],
+        ],
+        [
+          /(@identifier)(\s*[:=])/,
+          [PURE_GRAMMAR_TOKEN.PROPERTY, PURE_GRAMMAR_TOKEN.OPERATOR],
+        ],
+        [
+          /(@identifier)(\.)(@identifier)/,
+          [
+            PURE_GRAMMAR_TOKEN.TYPE,
+            PURE_GRAMMAR_TOKEN.OPERATOR,
+            PURE_GRAMMAR_TOKEN.PROPERTY,
+          ],
+        ], // profile tag and stereotype
 
-      package: [
-        [/(@package)(\*)/, ['package', 'tag']],
-        [/(@package)([\w_]+)/, ['package', 'type']],
+        // variables
         [
-          /(@package)([\w_]+)(\s*)(@multiplicity)/,
-          ['package', 'type', '', 'multiplicity'],
+          /(let)(\s+)(@identifier)(\s*[:=])/,
+          [
+            PURE_GRAMMAR_TOKEN.KEYWORD,
+            PURE_GRAMMAR_TOKEN.WHITESPACE,
+            PURE_GRAMMAR_TOKEN.VARIABLE,
+            PURE_GRAMMAR_TOKEN.OPERATOR,
+          ],
         ],
+        [/(\$@identifier)/, [PURE_GRAMMAR_TOKEN.VARIABLE]],
+      ],
+
+      date: [
+        [/(%latest)/, [`${PURE_GRAMMAR_TOKEN.DATE}.latest`]],
+        [/(@date)/, [PURE_GRAMMAR_TOKEN.DATE]],
+        [/(@time)/, [`${PURE_GRAMMAR_TOKEN.DATE}.time`]],
+      ],
+
+      color: [[/(#[0-9a-fA-F]{6})/, [PURE_GRAMMAR_TOKEN.COLOR]]],
+
+      number: [
         [
-          /([\w_]+)(\s*:\s*)(@package)([\w_]+)(\s*)(@multiplicity)/,
-          ['attribute', '', 'package', 'type', '', 'multiplicity'],
+          /(@digits)[eE]([-+]?(@digits))?[fFdD]?/,
+          `${PURE_GRAMMAR_TOKEN.NUMBER}.float`,
         ],
         [
-          /(:\s*)([\w_]+)(\s*)(@multiplicity)/,
-          ['', 'type', '', 'multiplicity'],
+          /(@digits)\.(@digits)([eE][-+]?(@digits))?[fFdD]?/,
+          `${PURE_GRAMMAR_TOKEN.NUMBER}.float`,
         ],
+        [/0[xX](@hexdigits)[Ll]?/, `${PURE_GRAMMAR_TOKEN.NUMBER}.hex`],
+        [/0(@octaldigits)[Ll]?/, `${PURE_GRAMMAR_TOKEN.NUMBER}.octal`],
+        [/0[bB](@binarydigits)[Ll]?/, `${PURE_GRAMMAR_TOKEN.NUMBER}.binary`],
+        [/(@digits)[fFdD]/, `${PURE_GRAMMAR_TOKEN.NUMBER}.float`],
+        [/(@digits)[lL]?/, PURE_GRAMMAR_TOKEN.NUMBER],
       ],
 
       whitespace: [
-        [/[ \t\r\n]+/, ''],
-        [/\/\*\*(?!\/)/, 'comment.doc', '@doc'],
-        [/\/\*/, 'comment', '@comment'],
-        [/\/\/.*$/, 'comment'],
+        [/[ \t\r\n]+/, PURE_GRAMMAR_TOKEN.WHITESPACE],
+        [/\/\*\*(?!\/)/, `${PURE_GRAMMAR_TOKEN.COMMENT}.doc`, '@doc'],
+        [/\/\*/, PURE_GRAMMAR_TOKEN.COMMENT, '@comment'],
+        [/\/\/.*$/, PURE_GRAMMAR_TOKEN.COMMENT],
       ],
 
       comment: [
-        [/[^/*]+/, 'comment'],
-        // [/\/\*/, 'comment', '@push' ],    // nested comment not allowed :-(
-        // [/\/\*/,    'comment.invalid' ],    // this breaks block comments in the shape of /* //*/
-        [/\*\//, 'comment', '@pop'],
-        [/[/*]/, 'comment'],
+        [/[^/*]+/, PURE_GRAMMAR_TOKEN.COMMENT],
+        // [/\/\*/, PURE_GRAMMAR_TOKEN.COMMENT, '@push' ],    // nested comment not allowed :-(
+        // [/\/\*/, ${PURE_GRAMMAR_TOKEN.COMMENT}.invalid` ],    // this breaks block comments in the shape of /* //*/
+        [/\*\//, PURE_GRAMMAR_TOKEN.COMMENT, '@pop'],
+        [/[/*]/, PURE_GRAMMAR_TOKEN.COMMENT],
       ],
 
       // Identical copy of comment above, except for the addition of .doc
       doc: [
-        [/[^/*]+/, 'comment.doc'],
-        // [/\/\*/, 'comment.doc', '@push' ],    // nested comment not allowed :-(
-        [/\/\*/, 'comment.doc.invalid'],
-        [/\*\//, 'comment.doc', '@pop'],
-        [/[/*]/, 'comment.doc'],
+        [/[^/*]+/, `${PURE_GRAMMAR_TOKEN.COMMENT}.doc`],
+        // [/\/\*/, `${PURE_GRAMMAR_TOKEN.COMMENT}.doc`, '@push' ],    // nested comment not allowed :-(
+        [/\/\*/, `${PURE_GRAMMAR_TOKEN.COMMENT}.doc.invalid`],
+        [/\*\//, `${PURE_GRAMMAR_TOKEN.COMMENT}.doc`, '@pop'],
+        [/[/*]/, `${PURE_GRAMMAR_TOKEN.COMMENT}.doc`],
       ],
 
       string: [
-        [/[^\\']+/, 'string'],
-        [/@escapes/, 'string.escape'],
-        [/\\./, 'string.escape.invalid'],
-        [/'/, 'string', '@pop'],
+        [/[^\\']+/, PURE_GRAMMAR_TOKEN.STRING],
+        [/@escapes/, `${PURE_GRAMMAR_TOKEN.STRING}.escape`],
+        [/\\./, `${PURE_GRAMMAR_TOKEN.STRING}.escape.invalid`],
+        [/'/, PURE_GRAMMAR_TOKEN.STRING, '@pop'],
       ],
 
       characters: [
-        [/'[^\\']'/, 'string'],
-        [/(')(@escapes)(')/, ['string', 'string.escape', 'string']],
-        [/'/, 'string.invalid'],
+        [/'[^\\']'/, PURE_GRAMMAR_TOKEN.STRING],
+        [
+          /(')(@escapes)(')/,
+          [
+            PURE_GRAMMAR_TOKEN.STRING,
+            `${PURE_GRAMMAR_TOKEN.STRING}.escape`,
+            PURE_GRAMMAR_TOKEN.STRING,
+          ],
+        ],
+        [/'/, `${PURE_GRAMMAR_TOKEN.STRING}.invalid`],
       ],
     },
   } as monacoLanguagesAPI.IMonarchLanguage);
@@ -362,6 +470,11 @@ export const setupPureLanguageService = (
   // Override `monaco-editor` native hotkeys
   // See https://github.com/microsoft/monaco-editor/issues/102#issuecomment-1282897640
   monacoEditorAPI.addKeybindingRules([
+    {
+      // disable cursor move (core command)
+      keybinding: KeyMod.WinCtrl | KeyCode.KeyB,
+      command: null,
+    },
     {
       // disable cursor move (core command)
       keybinding: KeyMod.WinCtrl | KeyCode.KeyO,
@@ -387,6 +500,11 @@ export const setupPureLanguageService = (
       keybinding: KeyCode.F9,
       command: null,
     },
+    {
+      // disable toggle debugger breakpoint
+      keybinding: KeyMod.Shift | KeyCode.F10,
+      command: null,
+    },
   ]);
   monacoLanguagesAPI.register({ id: EDITOR_LANGUAGE.PURE });
   monacoLanguagesAPI.setLanguageConfiguration(