github-linguist 5.2.0 → 5.3.0

data/grammars/source.vbnet.json

@@ -5,332 +5,270 @@
   "name": "VB.NET",
   "patterns": [
     {
-      "include": "#singleLineComment"
+      "include": "#comment-single-quote"
     },
     {
-      "include": "#region"
+      "include": "#comment-rem"
     },
     {
-      "include": "#quotedString"
+      "include": "#keyword-a"
     },
     {
-      "include": "#compilerOption"
+      "include": "#keyword-b"
     },
     {
-      "include": "#importDefinition"
+      "include": "#keyword-c"
     },
     {
-      "include": "#numericConstant"
+      "include": "#keyword-d"
     },
     {
-      "include": "#characterOperator"
+      "include": "#keyword-e"
     },
     {
-      "include": "#lineContinuationOperator"
+      "include": "#keyword-f"
     },
     {
-      "include": "#wordOperator"
+      "include": "#keyword-g"
     },
     {
-      "include": "#languageContants"
+      "include": "#keyword-h"
     },
     {
-      "include": "#compilerDirectives"
+      "include": "#keyword-i"
     },
     {
-      "include": "#supportTypes"
+      "include": "#keyword-j"
     },
     {
-      "include": "#suportFunctions"
+      "include": "#keyword-k"
     },
     {
-      "include": "#linqKeywords"
+      "include": "#keyword-l"
     },
     {
-      "include": "#languageVariable"
+      "include": "#keyword-m"
     },
     {
-      "include": "#namespaceDefinition"
+      "include": "#keyword-n"
     },
     {
-      "include": "#moduleDefinition"
+      "include": "#keyword-o"
     },
     {
-      "include": "#interfaceDefinition"
+      "include": "#keyword-p"
     },
     {
-      "include": "#classDefinition"
+      "include": "#keyword-r"
     },
     {
-      "include": "#functionDefinition"
+      "include": "#keyword-s"
     },
     {
-      "include": "#lambdaDefinition"
+      "include": "#keyword-t"
     },
     {
-      "include": "#propertyDefinition"
+      "include": "#keyword-u"
     },
     {
-      "include": "#propertyGetSet"
+      "include": "#keyword-v"
     },
     {
-      "include": "#definitionEnd"
+      "include": "#keyword-w"
     },
     {
-      "include": "#storageModifiers"
+      "include": "#keyword-x"
     },
     {
-      "include": "#inheritanceModifiers"
+      "include": "#keyword-y"
     },
     {
-      "include": "#controlKeywords"
+      "include": "#integer-literal"
     },
     {
-      "include": "#modifierKeywords"
+      "include": "#floating-point-literal"
     },
     {
-      "include": "#vbFunctions"
+      "include": "#character-literal"
+    },
+    {
+      "include": "#string-literal"
+    },
+    {
+      "include": "#date-literal"
+    },
+    {
+      "include": "#symbol"
+    },
+    {
+      "include": "#identifier"
     }
   ],
   "repository": {
-    "characterOperator": {
-      "match": "(\\.|\\+=|\\+|\\*=|\\*|\\\\=|\\\\|/=|/|=|-=|-|<|<=|>|>=|&=|&|\\^|\\^=|>>=|>>|<<=|<<|:=)",
-      "name": "keyword.operator.vbnet"
-    },
-    "classDefinition": {
-      "captures": {
-        "1": {
-          "name": "storage.type.class.vbnet"
-        },
-        "2": {
-          "name": "entity.name.type.class.vbnet"
-        }
-      },
-      "match": "(?i:\\b(class)\\s+([a-zA-Z_]\\w*)\\s*)",
-      "name": "meta.class.vbnet"
-    },
-    "compilerDirectives": {
-      "match": "^\\s*(?i:#if|#else|#elseif|#endif|#const|#externalsource|#end|#end externalsource)\\s+",
-      "name": "keyword.directive.vbnet"
-    },
-    "compilerOption": {
-      "captures": {
-        "1": {
-          "name": "keyword.other.compiler-option.vbnet"
-        },
-        "2": {
-          "name": "support.constant.compiler-option.vbnet"
-        },
-        "3": {
-          "name": "constant.language.option-value.vbnet"
-        }
-      },
-      "match": "(?i:^\\s*(option)\\s*(strict|infer|explicit|compare)\\s*(on|off|binary|text))"
-    },
-    "controlKeywords": {
-      "match": "(?i:\\b(If|Then|Else|ElseIf|Else If|End If|While|End While|For|End For|To|Each|Case|Select|End Select|Return|Continue|Do|Until|Loop|Next|End With|With|Exit Do|Exit For|Exit Function|Exit Property|Exit Sub|IIf|Step|GoTo|Try|Catch|Finally|End Try|Using|RaiseEvent|Stop|On Error|Resume|Async|Await|Yield)\\b)",
-      "name": "keyword.control.vbnet"
-    },
-    "definitionEnd": {
-      "match": "(?i:^\\s*(end)\\s+(function|sub|class|namespace|module|interface|property|addhandler|enum|event|operator|raiseevent|removehandler|select|structure|synclock))",
-      "name": "keyword.control.end-definition.vbnet"
-    },
-    "functionDefinition": {
-      "begin": "(?i:\\b(function|sub)\\s+([a-zA-Z_]\\w*)\\s*(\\()?)",
-      "beginCaptures": {
-        "1": {
-          "name": "support.type.function.vbnet"
-        },
-        "2": {
-          "name": "entity.name.function.vbnet"
-        },
-        "3": {
-          "name": "meta.parameters.vbnet"
-        },
-        "4": {
-          "name": "punctuation.definition.parameters.vbnet"
-        }
-      },
-      "end": "(\\))?\\s*",
-      "endCaptures": {
-        "1": {
-          "name": "punctuation.definition.parameters.vbnet"
-        }
-      },
-      "name": "meta.function.vbnet",
-      "patterns": [
-        {
-          "include": "#modifierKeywords"
-        },
-        {
-          "include": "#supportTypes"
-        }
-      ]
-    },
-    "importDefinition": {
-      "captures": {
-        "1": {
-          "name": "keyword.other.vbnet"
-        },
-        "2": {
-          "name": "variable.other.namespace-alias.vbnet"
-        }
-      },
-      "match": "(?i:^\\s*(imports)\\s*([a-zA-Z_]\\w*\\s*=)?\\s*([a-zA-Z_]\\w*\\.?)+)"
-    },
-    "inheritanceModifiers": {
-      "match": "(?i:overloads|overrides|overridable|notoverridable|mustoverride|mustoverride overrides|notoverridable overrides|overloads overrides|mustinherit|notinheritable)",
-      "name": "storage.modifier.inheritance.vbnet"
-    },
-    "interfaceDefinition": {
-      "captures": {
-        "1": {
-          "name": "storage.type.interface.vbnet"
-        },
-        "2": {
-          "name": "entity.name.type.interface.vbnet"
-        }
-      },
-      "match": "(?i:\\b(interface)\\s+([a-zA-Z_]\\w*)\\s*)",
-      "name": "meta.interface.vbnet"
-    },
-    "lambdaDefinition": {
-      "match": "(?i:function|sub)",
-      "name": "support.type.lambda.vbnet"
-    },
-    "languageContants": {
-      "match": "((?i:true|false|nothing))",
-      "name": "constant.language.vbnet"
-    },
-    "languageVariable": {
-      "match": "\\b((?i:Me|MyBase|MyClass))\\.",
-      "name": "keyword.other.vbnet"
-    },
-    "lineContinuationOperator": {
-      "match": "\\w*\\b(\\_)$",
-      "name": "keyword.operator.vbnet"
-    },
-    "linqKeywords": {
-      "match": "(?i:\\b(from|aggregate|select|where|order by|join|groupp by|into|group join|equals|let|distinct|skip|skip while|take|take while)\\b)",
-      "name": "keyword.control.linq.vbnet"
-    },
-    "modifierKeywords": {
-      "match": "\\b(?i:As|byval|byref|optional|handles|inherits|implements|withevents|end set|end get|of|alias|declare|widening|narrowing|ansi|assembly|auto|iterator|key|unicode)\\s+",
-      "name": "keyword.modifier.vbnet"
-    },
-    "moduleDefinition": {
-      "captures": {
-        "1": {
-          "name": "storage.type.module.vbnet"
-        },
-        "2": {
-          "name": "entity.name.type.module.vbnet"
-        }
-      },
-      "match": "(?i:\\b(module)\\s+([a-zA-Z_]\\w*)\\s*)",
-      "name": "meta.module.vbnet"
-    },
-    "namespaceDefinition": {
-      "captures": {
-        "1": {
-          "name": "storage.type.namespace.vbnet"
-        },
-        "2": {
-          "name": "entity.name.type.namespace.vbnet"
-        }
-      },
-      "match": "\\b((?i:namespace))\\s+([a-zA-Z_]\\w*)\\s*",
-      "name": "meta.namespace.vbnet"
-    },
-    "numericConstant": {
-      "match": "\\b(-?\\d+(\\.?\\d?)*)",
-      "name": "constant.numeric.vbnet"
-    },
-    "propertyDefinition": {
-      "begin": "(?i:\\b(property)\\s+([a-zA-Z_]\\w*)\\s*(\\()?)",
-      "beginCaptures": {
-        "1": {
-          "name": "storage.type.property.vbnet"
-        },
-        "2": {
-          "name": "entity.name.type.property.vbnet"
-        },
-        "3": {
-          "name": "punctuation.definition.parameters.property.vbnet"
-        }
-      },
-      "end": "(\\))?\\s*",
-      "endCaptures": {
-        "1": {
-          "name": "punctuation.definition.parameters.property.vbnet"
-        }
-      },
-      "name": "meta.property.vbnet",
-      "patterns": [
-        {
-          "include": "#modifierKeywords"
-        },
-        {
-          "include": "#supportTypes"
-        }
-      ]
-    },
-    "propertyGetSet": {
-      "match": "(?i:^\\s*(protected friend|protected|friend|private)?\\s+(get|set)\\s*\\(?\\b)",
-      "name": "keyword.other.property.accessor.vbnet"
-    },
-    "quotedString": {
-      "match": "(\")([^\"]|\"\")*(\")",
+    "character-literal": {
+      "comment": "char literals",
+      "match": "(?i:[\"\\x{201C}\\x{201D}]([^\"\\x{201C}\\x{201D}]|[\"\\x{201C}\\x{201D}]{2})[\"\\x{201C}\\x{201D}]C)",
       "name": "string.quoted.double.vbnet"
     },
-    "region": {
-      "begin": "^\\s*((?i:#region))",
-      "beginCaptures": {
-        "1": {
-          "name": "keyword.directive.vbnet"
-        }
-      },
-      "end": "^\\s*((?i:#end region))",
-      "endCaptures": {
-        "1": {
-          "name": "keyword.directive.vbnet"
-        }
-      },
-      "name": "meta.region.source.vbnet",
-      "patterns": [
-        {
-          "include": "$self"
-        }
-      ]
-    },
-    "singleLineComment": {
-      "comment": "single quote comment",
-      "match": "'.*$",
+    "comment-rem": {
+      "comment": "comments REM",
+      "match": "(?i)(?<=[^_\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Cf}\\p{Pc}])REM((?=[\\r|\\n])| [^\\r\\n]*)",
+      "name": "comment.line.singlequote.vbnet"
+    },
+    "comment-single-quote": {
+      "comment": "comments single-quote",
+      "match": "['\\x{2018}\\x{2019}][^\\r\\n]*",
       "name": "comment.line.singlequote.vbnet"
     },
-    "storageModifiers": {
-      "match": "\\b(?i:dim|public|private|protected friend|protected|friend|shadows|static|shared|readonly|default|partial|readonly|writeonly|erase|redim|lib)\\b",
-      "name": "storage.modifier.access.vbnet"
-    },
-    "suportFunctions": {
-      "match": "(?i:\\b(new|addressof|addhandler|removehandler|throw|typeof|like|call|synclock)\\b)",
-      "name": "support.function.vbnet"
-    },
-    "supportTypes": {
-      "match": "(?i:\\b(integer|decimal|double|single|date|long|short|char|string|byte|date|boolean|delegate|event|enum|sbyte|uinteger|ulong|ushort|const|object|global|paramarray)\\b)",
-      "name": "support.type.vbnet"
-    },
-    "vbFunctions": {
-      "captures": {
-        "1": {
-          "name": "support.function.vbnet"
-        }
-      },
-      "match": "\\b((?i:CBool|CByte|CChar|CDate|CDbl|CDec|Char|CInt|CLng|CObj|CSByte|CShort|CSng|CStr|CType|CUInt|CULng|CUShort|DirectCast|GetType|TryCast|GetXmlNamespace))\\("
-    },
-    "wordOperator": {
-      "match": "(?i:\\b(mod|not|and|andalso|or|orelse|in|is|isnot|xor|out)\\b)",
-      "name": "keyword.operator.vbnet"
+    "date-literal": {
+      "comment": "date literals",
+      "match": "(#\\s*(((((\\d+/\\d+/\\d+)|(\\d+-\\d+-\\d+))\\s+(\\d+:\\d+(:\\d+)?\\s*(AM|PM)?)))|((\\d+/\\d+/\\d+)|(\\d+-\\d+-\\d+))|(\\d+:\\d+(:\\d+)?\\s*(AM|PM)?))\\s*#)",
+      "name": "string.quoted.double.vbnet"
+    },
+    "floating-point-literal": {
+      "comment": "floating-point literals",
+      "match": "(?i:[0-9]*(\\.[0-9]+)?((?<=[0-9])E[+-]?[0-9]+)?(?<=[0-9])[FRD@&#]?)",
+      "name": "string.quoted.double.vbnet"
+    },
+    "identifier": {
+      "comment": "identifiers",
+      "match": "(([\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nl}]|_[_\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Cf}\\p{Pc}])[_\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Cf}\\p{Pc}]*[%&@!#$]?|\\[([\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nl}]|_[_\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Cf}\\p{Pc}])[_\\p{Lu}\\p{Ll}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nl}\\p{Nd}\\p{Mn}\\p{Mc}\\p{Cf}\\p{Pc}]*\\])",
+      "name": "variable.other.namespace-alias.vbnet"
+    },
+    "integer-literal": {
+      "comment": "integer literals",
+      "match": "(?i)(&H[0-9A-F]+|&O[0-7]+|&B[0-1]+|[0-9]+)(S|I|L|US|UI|UL|%|!)?",
+      "name": "string.quoted.double.vbnet"
+    },
+    "keyword-a": {
+      "comment": "keywords A",
+      "match": "(?i)(?<![.!])(AddHandler|AddressOf|Aggregate|Alias|And|AndAlso|Ansi|As|Ascending|Assembly|Async(?=\\s+(Sub|Function))|Auto|Await)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-b": {
+      "comment": "keywords B",
+      "match": "(?i)(?<![.!])((?<=Compare)\\s+Binary|Boolean|ByRef|Byte|ByVal)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-c": {
+      "comment": "keywords C",
+      "match": "(?i)(?<![.!])(Call|Case|Catch|CBool|CByte|CChar|CDate|CDbl|CDec|Char|CInt|Class|CLng|CObj|(?<=Option\\s)Compare|Const|Continue|CShort|CSng|CStr|CType|Custom(?=\\s+Event))\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-d": {
+      "comment": "keywords D",
+      "match": "(?i)(?<![.!])(Date|Decimal|Declare|Default|Delegate|Descending|Dim|DirectCast|Distinct|Do|Double)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-e": {
+      "comment": "keywords E",
+      "match": "(?i)(?<![.!])(Each|Else|ElseIf|End|EndIf|Enum|Equals|Erase|Error|Event|Exit|(?<=Option)\\s+Explicit)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-f": {
+      "comment": "keywords F",
+      "match": "(?i)(?<![.!])(False|Finally|For|Friend|From(?=\\s+{)|From|Function)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-g": {
+      "comment": "keywords G",
+      "match": "(?i)(?<![.!])(Get|GetType|Global|GoSub|GoTo|Group\\s+By|Group)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-h": {
+      "comment": "keywords H",
+      "match": "(?i)(?<![.!])(Handles)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-i": {
+      "comment": "keywords I",
+      "match": "(?i)(?<![.!])(If|Implements|Imports|In|(?<=Option)\\s+Infer|Inherits|Integer|Interface|Into|Is|IsNot|Iterator(?=\\s+(Function|Property)))\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-j": {
+      "comment": "keywords J",
+      "match": "(?i)(?<![.!])(Join)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-k": {
+      "comment": "keywords K",
+      "match": "(?i)(?<![.!])(Key)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-l": {
+      "comment": "keywords L",
+      "match": "(?i)(?<![.!])(Let|Lib|Like|Long|Loop)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-m": {
+      "comment": "keywords M",
+      "match": "(?i)(?<![.!])(Me|Mod|Module|MustInherit|MustOverride|MyBase|MyClass)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-n": {
+      "comment": "keywords N",
+      "match": "(?i)(?<![.!])(NameOf|Namespace|Narrowing|New|Next|Not|Nothing|NotInheritable|NotOverridable)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-o": {
+      "comment": "keywords",
+      "match": "(?i)(?<![.!])(Object|Of|(?<=Explicit|Infer|Strict)\\s+Off|On|Operator|Option|Optional|Or|Order\\s+By|OrElse|Out|Overloads|Overridable|Overrides)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-p": {
+      "comment": "keywords P",
+      "match": "(?i)(?<![.!])(ParamArray|Partial(?=\\s+(Class|Structure|Module|Interface))|Partial(?=\\s+(Class|Structure|Module|Interface|Sub|Public|Private|Protected|Friend|MustInherit|NotInheritable|NotOverrideable|Overridable|Shared))|Preserve|Private|Property|Protected|Public)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-r": {
+      "comment": "keywords R",
+      "match": "(?i)(?<![.!])(RaiseEvent|ReadOnly|ReDim|(?<=#|#End\\s)Region|RemoveHandler|Resume|Return)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-s": {
+      "comment": "keywords S",
+      "match": "(?i)(?<![.!])(Select|Set|Shadows|Shared|Short|Single|Skip|Static|Step|Stop|(?<=Option)\\s+Strict|String|Structure|Sub|SyncLock)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-t": {
+      "comment": "keywords T",
+      "match": "(?i)(?<![.!])(Take|(?<=Compare)\\s+Text|Then|Throw|To|True|Try|TryCast|TypeOf)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-u": {
+      "comment": "keywords U",
+      "match": "(?i)(?<![.!])(Unicode|Until|Using)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-v": {
+      "comment": "keywords B",
+      "match": "(?i)(?<![.!])(Variant)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-w": {
+      "comment": "keywords W",
+      "match": "(?i)(?<![.!])(Wend|When|Where|While|Widening|With|WithEvents|WriteOnly)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-x": {
+      "comment": "keywords X",
+      "match": "(?i)(?<![.!])(Xor)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "keyword-y": {
+      "comment": "keywords Y",
+      "match": "(?i)(?<![.!])(Yield)\\b",
+      "name": "keyword.other.vbnet"
+    },
+    "string-literal": {
+      "comment": "string literals",
+      "match": "([\"\\x{201C}\\x{201D}]([^\"\\x{201C}\\x{201D}]|[\"\\x{201C}\\x{201D}]{2})*[\"\\x{201C}\\x{201D}])",
+      "name": "string.quoted.double.vbnet"
+    },
+    "symbol": {
+      "comment": "symbols",
+      "match": "(([&*+\\-/\\\\^<=>])|([(){}!#,.:]|((?<= )_(?=\\s$)))|\\?)",
+      "name": "variable.other.namespace-alias.vbnet"
     }
   },
   "scopeName": "source.vbnet",