Fix and add patterns in language_java, language_kotlin and language_groovy.

manifest.json

@@ -1063,14 +1063,14 @@
       "version": "0.1"
     },
     {
-      "description": "Syntax for the [Groovy](https://en.wikipedia.org/wiki/Apache_Groovy) programming language",
+      "description": "Syntax for the [Groovy](https://en.wikipedia.org/wiki/Apache_Groovy) programming language.",
       "id": "language_groovy",
       "mod_version": "3",
       "path": "plugins/language_groovy.lua",
       "tags": [
         "language"
       ],
-      "version": "0.2"
+      "version": "0.3"
     },
     {
       "description": "Syntax for the [Hare](https://harelang.org) programming language",
@@ -1143,14 +1143,14 @@
       "version": "0.1"
     },
     {
-      "description": "Syntax for the [Java](https://en.wikipedia.org/wiki/Java_\\(programming_language\\)) programming language",
+      "description": "Syntax for the [Java](https://en.wikipedia.org/wiki/Java_\\(programming_language\\)) programming language.",
       "id": "language_java",
       "mod_version": "3",
       "path": "plugins/language_java.lua",
       "tags": [
         "language"
       ],
-      "version": "0.1.3"
+      "version": "0.1.4"
     },
     {
       "description": "Syntax for the [jiyu](https://github.com/machinamentum/jiyu) programming language",
@@ -1203,14 +1203,14 @@
       "version": "0.1"
     },
     {
-      "description": "Syntax for the [Kotlin](https://kotlinlang.org/docs/home.html) programming language",
+      "description": "Syntax for the [Kotlin](https://kotlinlang.org/docs/home.html) programming language.",
       "id": "language_kotlin",
       "mod_version": "3",
       "path": "plugins/language_kotlin.lua",
       "tags": [
         "language"
       ],
-      "version": "0.2"
+      "version": "0.3"
     },
     {
       "checksum": "08a9f8635b09a98cec9dfca8bb65f24fd7b6585c7e8308773e7ddff9a3e5a60f",

plugins/language_groovy.lua

@@ -1,33 +1,35 @@
 -- mod-version:3
 local syntax = require "core.syntax"
 
+-- Language Syntax References
+-- https://groovy-lang.org/syntax.html
+
 syntax.add {
   name = "Groovy",
-  files = { "%.groovy$" },
+  files = { "%.groovy$", "%.gvy$", "%.gy$", "%.gsh$" },
   comment = "//",
   block_comment = { "/*", "*/" },
   patterns = {
-    { pattern = "//.*",                          type = "comment"  }, -- Single-line comment
-    { pattern = { "/%*", "%*/" },                type = "comment"  }, -- Multi-line comment
-    { pattern = { '"', '"', '\\' },              type = "string"   }, -- String, double quotes
-    { pattern = { "'", "'", '\\' },              type = "string"   }, -- String, apices
-    { pattern = { "%/", "%/", '\\' },            type = "string"   }, -- Slashy string
-    { pattern = { "%$%/", "%/%$", '\\' },        type = "string"   }, -- Dollar slashy string
-    { pattern = "'\\x%x?%x?%x?%x'",              type = "string"   }, -- character hexadecimal escape sequence
-    { pattern = "'\\u%x%x%x%x'",                 type = "string"   }, -- character unicode escape sequence
-    { pattern = "'\\?.'",                        type = "string"   }, -- character literal
-    { pattern = "-?0x%x+",                       type = "number"   }, -- ?
-    { pattern = "-?%d+[%d%.eE]*[a-zA-Z]?",       type = "number"   }, -- ?
-    { pattern = "-?%.?%d+",                      type = "number"   }, -- ?
-    { pattern = "-?[%d_+]+[a-zA-Z]?",            type = "number"   }, -- ?
-    { pattern = "[%+%-=/%*%^%%<>!~|&]",          type = "operator" }, -- Operators
-    { pattern = "[%a_][%w_]*%f[(]",              type = "function" }, -- Function/Class/Method/...
-    { pattern = "[%a_][%w_]*%f[%[]",             type = "function" }, -- Custom Type
-    { regex   = "[A-Z]+_?[A-Z]+",                type = "keyword2" }, -- Constants
-    { pattern = "import()%s+()[%w_.]+",          type = { "keyword", "normal", "normal" } },
-    { pattern = "[%a_][%w_]*",                   type = "symbol"   }, -- ?
-    { pattern = "[a-zA-Z]+%.+",                  type = "function" }, -- Lib path
-    -- TODO: .class.
+    { pattern = "//.*",                              type = "comment"  }, -- Single-line comment
+    { pattern = { "/%*", "%*/" },                    type = "comment"  }, -- Multi-line comment
+    { pattern = { '"', '"', '\\' },                  type = "string"   }, -- String, double quotes (also matches triple quotes for multi-line string)
+    { pattern = { "'", "'", '\\' },                  type = "string"   }, -- String, apices
+    { pattern = { "%/", "%/", '\\' },                type = "string"   }, -- Slashy string
+    { pattern = { "%$%/", "%/%$", '\\' },            type = "string"   }, -- Dollar slashy string
+    { pattern = "'\\x%x?%x?%x?%x'",                  type = "string"   }, -- character hexadecimal escape sequence
+    { pattern = "'\\u%x%x%x%x'",                     type = "string"   }, -- character unicode escape sequence
+    { pattern = "'\\?.'",                            type = "string"   }, -- character literal
+    { pattern = "-?0x%x+",                           type = "number"   }, -- ?
+    { pattern = "-?%d+[%d%.eE]*[a-zA-Z]?",           type = "number"   }, -- ?
+    { pattern = "-?%.?%d+",                          type = "number"   }, -- ?
+    { pattern = "-?[%d_+]+[a-zA-Z]?",                type = "number"   }, -- ?
+    { pattern = "[%+%-=/%*%^%%<>!~|&]",              type = "operator" }, -- Operators
+    { pattern = "[%a_][%w_]*%f[(]",                  type = "function" }, -- Function/Method/Class/...
+    { pattern = "[%a_][%w_]*%f[%[]",                 type = "function" }, -- Custom Type
+    { regex   = [[[A-Z](?:[A-Z_][\d]*)+(?!\w)]],     type = "keyword2" }, -- Constants
+    { pattern = "import()%s+()[%w_.]+",              type = { "keyword", "normal", "normal" } },
+    { pattern = "%.class",                           type = "normal"   }, -- .class should be colored as normal
+    { pattern = "[%a_][%w_]*",                       type = "symbol"   }, -- ?
   },
   symbols = {
     -- Reserved keywords

plugins/language_java.lua

@@ -1,26 +1,33 @@
 -- mod-version:3
 local syntax = require "core.syntax"
 
+-- Language Syntax References
+-- https://docs.oracle.com/javase/specs/jls/se8/html/index.html
+
 syntax.add {
   name = "Java",
   files = { "%.java$" },
   comment = "//",
   patterns = {
-    { pattern = "//.*",                                           type = "comment"  },
-    { pattern = { "/%*", "%*/" },                                 type = "comment"  },
-    { pattern = { '"', '"', '\\' },                               type = "string"   },
-    { pattern = { "'", "'", '\\' },                               type = "string"   },
-    { pattern = "'\\x%x?%x?%x?%x'",                               type = "string"   }, -- character hexadecimal escape sequence
-    { pattern = "'\\u%x%x%x%x'",                                  type = "string"   }, -- character unicode escape sequence
-    { pattern = "'\\?.'",                                         type = "string"   }, -- character literal
-    { pattern = "-?0x%x+",                                        type = "number"   },
-    { pattern = "-?%d+[%d%.eE]*f?",                               type = "number"   },
-    { pattern = "-?%.?%d+f?",                                     type = "number"   },
-    { pattern = "[%+%-=/%*%^%%<>!~|&]",                           type = "operator" },
-    { pattern = "[%a_][%w_]*%f[(]",                               type = "function" },
-    { regex   = "(?>\\w+\\.?)+(?=\\s+\\w++\\s*\\=\\s*)",          type = "function" }, -- Class name when creating an object
-    { regex   = "[A-Z][A-Z_]+",                                   type = "keyword2" }, -- Constants
-    { pattern = "[%a_][%w_]*",                                    type = "symbol"   },
+    { pattern = "//.*",                             type = "comment"  }, -- Single-line comment
+    { pattern = { "/%*", "%*/" },                   type = "comment"  }, -- Multi-line comment
+    { pattern = { '"', '"', '\\' },                 type = "string"   }, -- String
+    { pattern = { "'", "'", '\\' },                 type = "string"   }, -- String
+    { pattern = "'\\x%x?%x?%x?%x'",                 type = "string"   }, -- character hexadecimal escape sequence
+    { pattern = "'\\u%x%x%x%x'",                    type = "string"   }, -- character unicode escape sequence
+    { pattern = "'\\?.'",                           type = "string"   }, -- character literal
+    { pattern = "-?0x%x+",                          type = "number"   }, -- Number: hexadecimal
+    { pattern = "-?%d+[%d%.eE]*[fFdD]?",            type = "number"   }, -- Number: exponential, float/double
+    { pattern = "%<.-%>%>*",                        type = "keyword2" }, -- Generic
+    { pattern = "[%+%-=/%*%^%%<>!~|&]",             type = "operator" }, -- Operator
+    { pattern = "[%a_][%w_]*%f[(]",                 type = "function" }, -- Method
+    { pattern = "^import()%s+()[%w_.]+",            type = { "keyword", "normal", "normal" } }, -- Import
+    { pattern = "[A-Z][A-Z_%d]+%f[^a-zA-Z_%d]",     type = "keyword2" }, -- Constants
+    { pattern = "this()%s*.*$",                     type = { "keyword", "normal" } }, -- FIX: ?
+    { pattern = "%@%w+",                            type = "keyword2" }, -- Annotation
+    { pattern = "%:%:()%w+",                        type = { "normal", "function" } }, -- Method reference with double colon operator
+    { pattern = "%.class",                          type = "normal"   }, -- .class should be colored as normal
+    { pattern = "[%a_][%w_]*",                      type = "symbol"   } -- Symbols
   },
   symbols = {
     ["abstract"]      = "keyword",
@@ -71,17 +78,17 @@ syntax.add {
     ["while"]         = "keyword",
     ["yield"]         = "keyword",
 
-    ["boolean"]       = "keyword2",
-    ["byte"]          = "keyword2",
-    ["char"]          = "keyword2",
-    ["double"]        = "keyword2",
-    ["float"]         = "keyword2",
-    ["int"]           = "keyword2",
-    ["long"]          = "keyword2",
-    ["short"]         = "keyword2",
+    ["boolean"]       = "keyword",
+    ["byte"]          = "keyword",
+    ["char"]          = "keyword",
+    ["double"]        = "keyword",
+    ["float"]         = "keyword",
+    ["int"]           = "keyword",
+    ["long"]          = "keyword",
+    ["short"]         = "keyword",
 
-    ["true"]     = "literal",
-    ["false"]    = "literal",
-    ["null"]     = "literal"
+    ["true"]          = "literal",
+    ["false"]         = "literal",
+    ["null"]          = "literal"
   }
 }

plugins/language_kotlin.lua

@@ -1,9 +1,13 @@
 -- mod-version:3
 local syntax = require "core.syntax"
 
+-- Language Syntax References
+-- https://kotlinlang.org/docs/basic-syntax.html
+-- https://kotlinlang.org/docs/keyword-reference.html
+
 syntax.add {
   name = "Kotlin",
-  files = { "%.kt$" },
+  files = { "%.kts?$", "%.klib$" },
   comment = "//",
   block_comment = { "/*", "*/" },
   patterns = {
@@ -14,23 +18,23 @@ syntax.add {
     { pattern = "'\\x%x?%x?%x?%x'",                  type = "string"   }, -- Character hexadecimal escape sequence
     { pattern = "'\\u%x%x%x%x'",                     type = "string"   }, -- Character unicode escape sequence
     { pattern = "'\\?.'",                            type = "string"   }, -- Character literal
+    { pattern = "%<.-%>%>*",                         type = "keyword2" }, -- Generic
     { pattern = "-?0x%x+",                           type = "number"   }, -- ?
     { pattern = "-?%d+[%deE]*f?",                    type = "number"   }, -- ?
     { pattern = "-?%.?%d+f?",                        type = "number"   }, -- ?
     { regex   = [[\-\>(?=\s)]],                      type = "operator" }, -- Lambda
     { regex   = [[\.{2}\<?\s?(?=[\\-]?[a-z0-9])]],   type = "operator" }, -- Range operators
     { pattern = "[%+%-=/%*%^%%<>!~|&]",              type = "operator" }, -- Operators
-    { regex   = [[\?(?=\.)]],                        type = "operator" }, -- ?. operator
     { pattern = "[%a_][%w_]*%f[(]",                  type = "function" }, -- Function/Method/Class
-    { regex   = "`[\\w_\\s]+`(?=\\s*\\()",           type = "function" }, -- Test Method
+    { regex   = [[`[\w_\s]+`(?=\s*\()]],             type = "function" }, -- Test Method
     { regex   = [[let(?=\s\{)]],                     type = "function" }, -- ? operator
     { regex   = [[\?\:(?=\s?)]],                     type = "operator" }, -- elvis operator
     { regex   = [[this(?=\.?\@?)]],                  type = "keyword"  }, -- this keyword
-    { regex   = "\\@\\w+",                           type = "keyword2" }, -- Annotations
-    { regex   = [[[a-zA-Z]+\@(?=\s?[a-zA-Z])]],      type = "keyword2" }, -- Annotations (this pattern is lower priority than the `this keyword` pattern)
-    { regex   = "[A-Z][A-Z_]+",                      type = "keyword2" }, -- Constants, FULL UPPERCASE
-    { pattern = "import()%s+()[%w_.]+",              type = { "keyword", "normal", "normal" } },
-    { pattern = "[%a_][%w_]*",                       type = "symbol"   }, -- ?
+    { pattern = "%@[%w%.]+",                         type = "keyword2" }, -- Annotation
+    { pattern = "^import()%s+()[%w_.]+",             type = { "keyword", "normal", "normal" } },
+    { pattern = "[A-Z][A-Z_%d]+%f[^a-zA-Z_%d]",      type = "keyword2" }, -- Constants
+    { pattern = "%:%s()%w+",                         type = { "normal", "function" } }, -- Type reference
+    { pattern = "[%a_][%w_]*",                       type = "symbol"   }, -- Symbols
   },
   symbols = {
     -- Hard keywords
@@ -81,6 +85,7 @@ syntax.add {
     ["setparam"]     = "keyword",
     ["value"]        = "keyword",
     ["where"]        = "keyword",
+    ["to"]           = "keyword",
 
     -- Modifier keywords
     ["abstract"]     = "keyword",