diff --git a/Java/CSS (for JSP).sublime-syntax b/Java/CSS (for JSP).sublime-syntax new file mode 100644 index 0000000000..3b2864d328 --- /dev/null +++ b/Java/CSS (for JSP).sublime-syntax @@ -0,0 +1,32 @@ +%YAML 1.2 +--- +############################################################################### +# This intermediate syntax is used by `HTML (JSP).sublime-syntax` +# +# It powers Java highlighting within JSP tags in embedded CSS. +# +# +# +# The primary task is to add `jsp-embedded` context to CSS's prototype +# to highlight all the <% %> tags. +############################################################################### + +scope: source.css.embedded.jsp +version: 2 +hidden: true + +extends: Packages/CSS/CSS.sublime-syntax + +contexts: + + prototype: + - meta_prepend: true + - include: HTML (JSP).sublime-syntax#jsp-embedded + + string-content: + - meta_prepend: true + - include: HTML (JSP).sublime-syntax#jsp-interpolations diff --git a/Java/Comments - Properties.tmPreferences b/Java/Comments - Properties.tmPreferences deleted file mode 100644 index 7462ae5c97..0000000000 --- a/Java/Comments - Properties.tmPreferences +++ /dev/null @@ -1,27 +0,0 @@ - - - - name - Comments - Properties - scope - source.java-props - settings - - shellVariables - - - name - TM_COMMENT_START - value - # - - - name - TM_COMMENT_START_2 - value - ! - - - - - diff --git a/Java/Default.sublime-keymap b/Java/Default.sublime-keymap new file mode 100644 index 0000000000..92a4a90a52 --- /dev/null +++ b/Java/Default.sublime-keymap @@ -0,0 +1,27 @@ +[ + // Auto-pair double quotes (also if followed by comma or semicolon) + // Example: key: |; -> key: "|"; + { "keys": ["\""], "command": "insert_snippet", "args": {"contents": "\"$0\""}, "context": + [ + { "key": "setting.auto_match_enabled", "operator": "equal", "operand": true }, + { "key": "selection_empty", "operator": "equal", "operand": true, "match_all": true }, + { "key": "selector", "operator": "equal", "operand": "source.java - string", "match_all": true }, + { "key": "following_text", "operator": "regex_contains", "operand": "^(?:\t| |\\)|]|\\}|>|,|:|;|\\+|$)", "match_all": true }, + { "key": "preceding_text", "operator": "not_regex_contains", "operand": "[\"a-zA-Z0-9_]$", "match_all": true }, + { "key": "eol_selector", "operator": "not_equal", "operand": "string.quoted.double - punctuation.definition.string.end", "match_all": true } + ] + }, + + // Auto-pair double quotes (also if followed by comma or semicolon) + // Example: key: |; -> key: '|'; + { "keys": ["'"], "command": "insert_snippet", "args": {"contents": "'$0'"}, "context": + [ + { "key": "setting.auto_match_enabled", "operator": "equal", "operand": true }, + { "key": "selection_empty", "operator": "equal", "operand": true, "match_all": true }, + { "key": "selector", "operator": "equal", "operand": "source.java - string", "match_all": true }, + { "key": "following_text", "operator": "regex_contains", "operand": "^(?:\t| |\\)|]|\\}|>|,|:|;|\\+|$)", "match_all": true }, + { "key": "preceding_text", "operator": "not_regex_contains", "operand": "['a-zA-Z0-9_]$", "match_all": true }, + { "key": "eol_selector", "operator": "not_equal", "operand": "string.quoted.double - punctuation.definition.string.end", "match_all": true } + ] + }, +] \ No newline at end of file diff --git a/Java/HTML (JSP).sublime-syntax b/Java/HTML (JSP).sublime-syntax new file mode 100644 index 0000000000..47218d9490 --- /dev/null +++ b/Java/HTML (JSP).sublime-syntax @@ -0,0 +1,503 @@ +%YAML 1.2 +--- +# https://www.oracle.com/technetwork/java/syntaxref12-149806.pdf +# https://www.sublimetext.com/docs/syntax.html +name: HTML (JSP) +scope: text.html.jsp +version: 2 + +extends: Packages/HTML/HTML.sublime-syntax + +file_extensions: + - jsp + - jspf + - jspx + +contexts: + + prototype: + - meta_prepend: true + - include: jsp-embedded + +###[ HTML CUSTOM TAGS ]####################################################### + + tag-other: + - meta_prepend: true + - include: tag-jsp-declaration + - include: tag-jsp-directive + - include: tag-jsp-expression + - include: tag-jsp-scriptlet + - include: tag-jsp-other + - include: tag-jstl + + script-javascript-content: + - meta_include_prototype: false + - match: '{{script_content_begin}}' + captures: + 1: comment.block.html punctuation.definition.comment.begin.html + pop: 1 # make sure to match only once + embed: scope:source.js.embedded.jsp + embed_scope: source.js.embedded.html + escape: '{{script_content_end}}' + escape_captures: + 1: source.js.embedded.html + 2: comment.block.html punctuation.definition.comment.end.html + 3: source.js.embedded.html + 4: comment.block.html punctuation.definition.comment.end.html + + style-css-content: + - meta_include_prototype: false + - match: '{{style_content_begin}}' + captures: + 1: comment.block.html punctuation.definition.comment.begin.html + pop: 1 # make sure to match only once + embed: scope:source.css.embedded.jsp + embed_scope: source.css.embedded.html + escape: '{{style_content_end}}' + escape_captures: + 1: source.css.embedded.html + 2: comment.block.html punctuation.definition.comment.end.html + 3: source.css.embedded.html + 4: comment.block.html punctuation.definition.comment.end.html + + tag-event-attribute-value: + - match: \" + scope: + meta.string.html string.quoted.double.html + punctuation.definition.string.begin.html + embed: scope:source.js.embedded.jsp + embed_scope: + meta.string.html meta.interpolation.html + source.js.embedded.html + escape: \" + escape_captures: + 0: meta.string.html string.quoted.double.html + punctuation.definition.string.end.html + - match: \' + scope: + meta.string.html string.quoted.single.html + punctuation.definition.string.begin.html + embed: scope:source.js.embedded.jsp + embed_scope: + meta.string.html meta.interpolation.html + source.js.embedded.html + escape: \' + escape_captures: + 0: meta.string.html string.quoted.single.html + punctuation.definition.string.end.html + - include: else-pop + + tag-style-attribute-value: + - match: \" + scope: + meta.string.html string.quoted.double.html + punctuation.definition.string.begin.html + embed: scope:source.css.embedded.jsp#rule-list-body + embed_scope: + meta.string.html meta.interpolation.html + source.css.embedded.html + escape: \" + escape_captures: + 0: meta.string.html string.quoted.double.html + punctuation.definition.string.end.html + - match: \' + scope: + meta.string.html string.quoted.single.html + punctuation.definition.string.begin.html + embed: scope:source.css.embedded.jsp#rule-list-body + embed_scope: + meta.string.html meta.interpolation.html + source.css.embedded.html + escape: \' + escape_captures: + 0: meta.string.html string.quoted.single.html + punctuation.definition.string.end.html + - include: else-pop + + tag-href-attribute: + - meta_append: true + - include: tag-xmlns-attribute + + tag-xmlns-attribute: + - match: ((?i:xmlns))(?:(:)([^{{attribute_name_break_char}}]+))?{{attribute_name_break}} + captures: + 1: entity.other.attribute-name.namespace.html + 2: punctuation.separator.namespace.html + 3: entity.other.attribute-name.localname.html + push: + - tag-xmlns-attributes-meta + - tag-href-attributes-assignment + + tag-xmlns-attributes-meta: + - meta_include_prototype: false + - meta_scope: meta.attribute-with-value.xmlns.html + - include: immediately-pop + + tag-attribute-value-content: + - meta_prepend: true + - include: jsp-interpolations + + strings-common-content: + - meta_prepend: true + - include: jsp-interpolations + +###[ JSP TAG DECLARATION ]#################################################### + + tag-jsp-declaration: + - match: (?i)(<)(jsp)(:)(declaration){{tag_name_break}} + captures: + 1: punctuation.definition.tag.begin.html + 2: entity.name.tag.namespace.html + 3: entity.name.tag.html punctuation.separator.namespace.html + 4: entity.name.tag.localname.html + push: tag-jsp-declaration-attributes + - match: (?i)(' + scope: + meta.tag.jsp.declaration.begin.html + punctuation.definition.tag.end.html + pop: 1 + embed: scope:source.java.embedded.html + embed_scope: source.java.embedded.jsp + escape: (?=' + scope: + meta.tag.jsp.expression.begin.html + punctuation.definition.tag.end.html + pop: 1 + embed: scope:source.java.embedded.html#expressions + embed_scope: source.java.embedded.jsp + escape: (?=' + scope: + meta.tag.jsp.scriptlet.begin.html + punctuation.definition.tag.end.html + pop: 1 + embed: scope:source.java.embedded.html + embed_scope: source.java.embedded.jsp + escape: (?= + scope: punctuation.definition.comment.end.jsp + pop: 1 + + jsp-embedded-declarations: + - match: <%! + scope: + meta.embedded.declaration.jsp + punctuation.section.embedded.begin.jsp + embed: scope:source.java.embedded.jsp + embed_scope: + meta.embedded.declaration.jsp + source.java.embedded.jsp + escape: \%> + escape_captures: + 0: meta.embedded.declaration.jsp + punctuation.section.embedded.end.jsp + + jsp-embedded-directives: + - match: <%@ + scope: punctuation.section.embedded.begin.jsp + push: jsp-embedded-directives-common + + jsp-embedded-directives-common: + - meta_include_prototype: false + - meta_scope: meta.embedded.directive.jsp + - match: \%> + scope: punctuation.section.embedded.end.jsp + pop: 1 + - match: \w+ + scope: keyword.control.directive.jsp + push: jsp-embedded-directives-content + + jsp-embedded-directives-content: + - meta_include_prototype: false + - match: \w+ + scope: entity.other.attribute-name.jsp + - match: = + scope: punctuation.separator.key-value.jsp + - include: jsp-strings-double-quoted + - include: jsp-strings-single-quoted + - include: else-pop + + jsp-embedded-expressions: + - match: <%= + scope: + meta.embedded.expression.jsp + punctuation.section.embedded.begin.jsp + embed: scope:source.java.embedded.jsp#expressions + embed_scope: + meta.embedded.expression.jsp + source.java.embedded.jsp + escape: \%> + escape_captures: + 0: meta.embedded.expression.jsp + punctuation.section.embedded.end.jsp + + jsp-embedded-scriptlets: + - match: <% + scope: + meta.embedded.scriptlet.jsp + punctuation.section.embedded.begin.jsp + embed: scope:source.java.embedded.jsp + embed_scope: + meta.embedded.scriptlet.jsp + source.java.embedded.jsp + escape: \%> + escape_captures: + 0: meta.embedded.scriptlet.jsp + punctuation.section.embedded.end.jsp + +###[ JSP CONSTANTS ]########################################################## + + jsp-strings-double-quoted: + - match: \" + scope: punctuation.definition.string.begin.jsp + push: jsp-strings-double-quoted-content + + jsp-strings-double-quoted-content: + - meta_include_prototype: false + - meta_scope: meta.string.jsp string.quoted.double.jsp + - match: \" + scope: punctuation.definition.string.end.jsp + pop: 1 + - include: jsp-string-escapes + + jsp-strings-single-quoted: + - match: \' + scope: punctuation.definition.string.begin.jsp + push: jsp-strings-single-quoted-content + + jsp-strings-single-quoted-content: + - meta_include_prototype: false + - meta_scope: meta.string.jsp string.quoted.single.jsp + - match: \' + scope: punctuation.definition.string.end.jsp + pop: 1 + - include: jsp-string-escapes + + jsp-string-escapes: + - match: \\. + scope: constant.character.escape.jsp diff --git a/Java/Indentation Rules Annex.tmPreferences b/Java/Indentation Rules Annex.tmPreferences deleted file mode 100644 index 83689d8523..0000000000 --- a/Java/Indentation Rules Annex.tmPreferences +++ /dev/null @@ -1,14 +0,0 @@ - - - - name - Indentation Rules Annex - scope - source.java - settings - - unIndentedLinePattern - ^\s*((\*/|//| \*).*)?$ - - - diff --git a/Java/Indentation Rules.tmPreferences b/Java/Indentation Rules.tmPreferences deleted file mode 100644 index 0373ea5982..0000000000 --- a/Java/Indentation Rules.tmPreferences +++ /dev/null @@ -1,22 +0,0 @@ - - - - name - Indentation Rules - scope - source.java - comment - settings - - decreaseIndentPattern - ^(.*\*/)?\s*\}.*$|^\s*(public|private|protected):\s*$ - increaseIndentPattern - ^.*\{[^}"']*$|^\s*(public|private|protected):\s*$ - - bracketIndentNextLinePattern - (?x) - ^ \s* \b(if|while|else)\b [^;]* $ - | ^ \s* \b(for)\b .* $ - - - - diff --git a/Java/Java (for HTML).sublime-syntax b/Java/Java (for HTML).sublime-syntax new file mode 100644 index 0000000000..dae98e7505 --- /dev/null +++ b/Java/Java (for HTML).sublime-syntax @@ -0,0 +1,45 @@ +%YAML 1.2 +--- +############################################################################### +# This intermediate syntax is used by `HTML (JSP).sublime-syntax` +# +# It powers Java highlighting within following XML noted JSP tags: +# ... +# ... +# ... +# +# The primary tasks are: +# 1) to disable stray bracket highlighting +# 2) highlight HTML entities within Java code +# 3) highlight CDATA tags within Java code +############################################################################### + +scope: source.java.embedded.html +version: 2 +hidden: true + +extends: Java.sublime-syntax + +contexts: + + prototype: + - meta_append: true + - include: HTML (Plain).sublime-syntax#entities + - match: (' + scope: + meta.tag.sgml.cdata.html + punctuation.definition.tag.end.html + + stray-braces: + - match: \} + scope: punctuation.section.block.end.java + + stray-group: + - match: \) + scope: punctuation.section.group.end.java diff --git a/Java/Java (for JSP).sublime-syntax b/Java/Java (for JSP).sublime-syntax new file mode 100644 index 0000000000..50c9023f58 --- /dev/null +++ b/Java/Java (for JSP).sublime-syntax @@ -0,0 +1,35 @@ +%YAML 1.2 +--- +############################################################################### +# This intermediate syntax is used by `HTML (JSP).sublime-syntax` +# +# It powers Java highlighting within following JSP embedding tags: +# <%! ... %> +# <%= ... %> +# <% ... %> +# +# The primary tasks are: +# 1) to disable stray bracket highlighting +# 2) highlight escaped %> end tags +############################################################################### + +scope: source.java.embedded.jsp +version: 2 +hidden: true + +extends: Java.sublime-syntax + +contexts: + + stray-braces: + - match: \} + scope: punctuation.section.block.end.java + + stray-group: + - match: \) + scope: punctuation.section.group.end.java + + literal-string-escapes: + # escaped <% and %> to not detect them as end of interpolation + - match: <\\%|%\\> + scope: constant.character.escape.jsp diff --git a/Java/Comments.tmPreferences b/Java/Java - Comments.tmPreferences similarity index 93% rename from Java/Comments.tmPreferences rename to Java/Java - Comments.tmPreferences index a880b9ecd8..8b104c6c51 100644 --- a/Java/Comments.tmPreferences +++ b/Java/Java - Comments.tmPreferences @@ -1,8 +1,6 @@ - name - Comments scope source.java settings diff --git a/Java/Completion Rules.tmPreferences b/Java/Java - Completion Rules.tmPreferences similarity index 55% rename from Java/Completion Rules.tmPreferences rename to Java/Java - Completion Rules.tmPreferences index 093a13fc99..111327de91 100644 --- a/Java/Completion Rules.tmPreferences +++ b/Java/Java - Completion Rules.tmPreferences @@ -6,7 +6,10 @@ settings cancelCompletion - ^\s*(\}?\s*(else|try|do|finally)|(class|package|enum)\s*[a-zA-Z_0-9]+*)$ + diff --git a/Java/Java - Indentation Rules (Comments).tmPreferences b/Java/Java - Indentation Rules (Comments).tmPreferences new file mode 100644 index 0000000000..6cab147cab --- /dev/null +++ b/Java/Java - Indentation Rules (Comments).tmPreferences @@ -0,0 +1,27 @@ + + + + scope + source.java comment.block + settings + + + preserveIndent + + unIndentedLinePattern + . + + + diff --git a/Java/Java - Indentation Rules.tmPreferences b/Java/Java - Indentation Rules.tmPreferences new file mode 100644 index 0000000000..6961675b36 --- /dev/null +++ b/Java/Java - Indentation Rules.tmPreferences @@ -0,0 +1,84 @@ + + + + scope + source.java + settings + + decreaseIndentPattern + + increaseIndentPattern + + bracketIndentNextLinePattern + (?: \s* (? /\*.*\*/ ) )* \s* ) + (?: + # indent after: + # - `else` + else + # indent after: + # - `else if (...)` + # - `if (...)` + # - `for (...)` + # - `while (...)` + | (?: (?: else \g )? if | for | while ) + # followed by whitespace or block comments [optional] + \g + # top-level balanced parentheses + \( + (? (?: + # nested balanced parentheses + \( \g \) + # double quoted string with ignored escaped quotation marks + | \".*(? + # anything but closing parenthesis + | [^)] + )* ) + # maybe missing, balanced or stray closing parenthesis + \)* + ) + # followed by whitespace or block comments [optional] + \g + # followed by line comment [optional] + (?: //.* )? $ + ]]> + preserveIndent + + unIndentedLinePattern + + + + diff --git a/Java/Java Server Pages (JSP).sublime-syntax b/Java/Java Server Pages (JSP).sublime-syntax deleted file mode 100644 index f34f5e58cf..0000000000 --- a/Java/Java Server Pages (JSP).sublime-syntax +++ /dev/null @@ -1,87 +0,0 @@ -%YAML 1.2 ---- -# http://www.sublimetext.com/docs/3/syntax.html -name: Java Server Page (JSP) -file_extensions: - - jsp -scope: text.html.jsp -contexts: - main: - - match: <%-- - scope: punctuation.definition.comment.jsp - push: - - meta_scope: comment.block.jsp - - match: "--%>" - scope: punctuation.definition.comment.jsp - pop: true - - match: <%@ - scope: punctuation.section.directive.jsp - push: - - meta_scope: meta.directive.jsp - - match: "%>" - scope: punctuation.section.directive.jsp - pop: true - - match: \w+ - scope: keyword.other.directive.jsp - push: - - match: \w+ - scope: constant.other.directive.attribute.jsp - - match: "=" - scope: keyword.operator.assignment.jsp - - match: '"' - scope: punctuation.definition.string.begin.jsp - push: - - meta_scope: string.quoted.double.jsp - - match: '"' - scope: punctuation.definition.string.end.jsp - pop: true - - match: \\. - scope: constant.character.escape.jsp - - match: "'" - scope: punctuation.definition.string.begin.jsp - push: - - meta_scope: string.quoted.single.jsp - - match: "'" - scope: punctuation.definition.string.end.jsp - pop: true - - match: \\. - scope: constant.character.escape.jsp - - match: '(?=\S)' - pop: true - - match: "(<%[!=]?)|(||)" - captures: - 1: punctuation.section.embedded.begin.jsp - 2: meta.tag.block.jsp - push: - - match: (||)|(%>) - captures: - 1: meta.tag.block.jsp - 2: punctuation.section.embedded.end.jsp - pop: true - - match: '(?|||%>|\{|\})' - push: - - meta_scope: source.java.embedded.html - - match: '(?=|||%>|\{|\})|\n' - pop: true - - include: scope:source.java - - match: "{" - push: - - match: "}" - pop: true - - match: (||)|(%>) - captures: - 1: meta.tag.block.jsp - 2: punctuation.section.embedded.end.jsp - push: - - match: "(||)|(<%(?!--)[!=]?)" - captures: - 1: meta.tag.block.jsp - 2: punctuation.section.embedded.begin.jsp - pop: true - - include: scope:text.html.jsp - - include: scope:source.java - # Prevent stray brace detection since brace matching won't work with - # %> pop pattern - - match: "}" - - include: scope:source.java - - include: scope:text.html.basic diff --git a/Java/Java.sublime-completions b/Java/Java.sublime-completions index 9b302bda0a..d5c92dc510 100644 --- a/Java/Java.sublime-completions +++ b/Java/Java.sublime-completions @@ -5,254 +5,248 @@ "completions": [ // Keywords { - "trigger": "abstract", - "contents": "abstract", + "trigger": "assert", "kind": "keyword" }, { - "trigger": "continue", - "contents": "continue", + "trigger": "break", "kind": "keyword" }, { - "trigger": "for", - "contents": "for", + "trigger": "case", "kind": "keyword" }, { - "trigger": "new", - "contents": "new", + "trigger": "catch", "kind": "keyword" }, { - "trigger": "switch", - "contents": "switch", + "trigger": "class", "kind": "keyword" }, { - "trigger": "assert", - "contents": "assert", + "trigger": "continue", "kind": "keyword" }, { "trigger": "default", - "contents": "default", "kind": "keyword" }, { - "trigger": "goto", - "contents": "goto", + "trigger": "do", "kind": "keyword" }, { - "trigger": "package", - "contents": "package", + "trigger": "double", "kind": "keyword" }, { - "trigger": "synchronized", - "contents": "synchronized", + "trigger": "else", "kind": "keyword" }, { - "trigger": "boolean", - "contents": "boolean", + "trigger": "enum", "kind": "keyword" }, { - "trigger": "do", - "contents": "do", + "trigger": "extends", "kind": "keyword" }, { - "trigger": "if", - "contents": "if", + "trigger": "finally", "kind": "keyword" }, { - "trigger": "private", - "contents": "private", + "trigger": "for", "kind": "keyword" }, { - "trigger": "this", - "contents": "this", + "trigger": "if", "kind": "keyword" }, { - "trigger": "break", - "contents": "break", + "trigger": "implements", "kind": "keyword" }, { - "trigger": "double", - "contents": "double", + "trigger": "import", "kind": "keyword" }, { - "trigger": "implements", - "contents": "implements", + "trigger": "instanceof", "kind": "keyword" }, { - "trigger": "protected", - "contents": "protected", + "trigger": "interface", "kind": "keyword" }, { - "trigger": "throw", - "contents": "throw", + "trigger": "new", "kind": "keyword" }, { - "trigger": "byte", - "contents": "byte", + "trigger": "package", "kind": "keyword" }, { - "trigger": "else", - "contents": "else", + "trigger": "record", "kind": "keyword" }, { - "trigger": "import", - "contents": "import", + "trigger": "return", "kind": "keyword" }, { - "trigger": "public", - "contents": "public", + "trigger": "switch", "kind": "keyword" }, { - "trigger": "throws", - "contents": "throws", + "trigger": "synchronized", "kind": "keyword" }, { - "trigger": "case", - "contents": "case", + "trigger": "throw", "kind": "keyword" }, { - "trigger": "enum", - "contents": "enum", + "trigger": "throws", "kind": "keyword" }, { - "trigger": "instanceof", - "contents": "instanceof", + "trigger": "try", "kind": "keyword" }, { - "trigger": "return", - "contents": "return", + "trigger": "var", "kind": "keyword" }, { - "trigger": "transient", - "contents": "transient", + "trigger": "void", "kind": "keyword" }, { - "trigger": "catch", - "contents": "catch", + "trigger": "while", "kind": "keyword" }, { - "trigger": "extends", - "contents": "extends", + "trigger": "yield", "kind": "keyword" }, + + // Built-In Constants { - "trigger": "int", - "contents": "int", - "kind": "keyword" + "trigger": "false", + "annotation": "built-in", + "kind": ["variable", "c", "Constant"] }, { - "trigger": "short", - "contents": "short", - "kind": "keyword" + "trigger": "null", + "annotation": "built-in", + "kind": ["variable", "c", "Constant"] }, { - "trigger": "try", - "contents": "try", - "kind": "keyword" + "trigger": "true", + "annotation": "built-in", + "kind": ["variable", "c", "Constant"] }, + + // Built-In Modifiers { - "trigger": "char", - "contents": "char", - "kind": "keyword" + "trigger": "abstract", + "kind": ["keyword", "m", "Modifier"] }, { "trigger": "final", - "contents": "final", - "kind": "keyword" + "kind": ["keyword", "m", "Modifier"] }, { - "trigger": "interface", - "contents": "interface", - "kind": "keyword" + "trigger": "native", + "kind": ["keyword", "m", "Modifier"] }, { - "trigger": "static", - "contents": "static", - "kind": "keyword" + "trigger": "permits", + "kind": ["keyword", "m", "Modifier"] }, { - "trigger": "void", - "contents": "void", - "kind": "keyword" + "trigger": "private", + "kind": ["keyword", "m", "Modifier"] }, { - "trigger": "class", - "contents": "class", - "kind": "keyword" + "trigger": "protected", + "kind": ["keyword", "m", "Modifier"] }, { - "trigger": "finally", - "contents": "finally", - "kind": "keyword" + "trigger": "public", + "kind": ["keyword", "m", "Modifier"] }, { - "trigger": "long", - "contents": "long", - "kind": "keyword" + "trigger": "static", + "kind": ["keyword", "m", "Modifier"] }, { "trigger": "strictfp", - "contents": "strictfp", - "kind": "keyword" + "kind": ["keyword", "m", "Modifier"] + }, + { + "trigger": "sealed", + "kind": ["keyword", "m", "Modifier"] + }, + { + "trigger": "transient", + "kind": ["keyword", "m", "Modifier"] }, { "trigger": "volatile", - "contents": "volatile", - "kind": "keyword" + "kind": ["keyword", "m", "Modifier"] }, + + // Built-In Types { - "trigger": "const", - "contents": "const", - "kind": "keyword" + "trigger": "boolean", + "annotation": "built-in", + "kind": "type" + }, + { + "trigger": "byte", + "annotation": "built-in", + "kind": "type" + }, + { + "trigger": "char", + "annotation": "built-in", + "kind": "type" }, { "trigger": "float", - "contents": "float", - "kind": "keyword" + "annotation": "built-in", + "kind": "type" }, { - "trigger": "native", - "contents": "native", - "kind": "keyword" + "trigger": "int", + "annotation": "built-in", + "kind": "type" + }, + { + "trigger": "long", + "annotation": "built-in", + "kind": "type" + }, + { + "trigger": "short", + "annotation": "built-in", + "kind": "type" }, + + // Built-In Variables { "trigger": "super", - "contents": "super", - "kind": "keyword" + "annotation": "built-in", + "kind": "variable" }, { - "trigger": "while", - "contents": "while", - "kind": "keyword" + "trigger": "this", + "annotation": "built-in", + "kind": "variable" }, // Extracted from https://docs.oracle.com/javase/8/docs/api/java/lang/package-summary.html @@ -260,42 +254,34 @@ // java.lang interfaces { "trigger": "Appendable", - "contents": "Appendable", "kind": ["type", "i", "Interface"] }, { "trigger": "AutoCloseable", - "contents": "AutoCloseable", "kind": ["type", "i", "Interface"] }, { "trigger": "CharSequence", - "contents": "CharSequence", "kind": ["type", "i", "Interface"] }, { "trigger": "Cloneable", - "contents": "Cloneable", "kind": ["type", "i", "Interface"] }, { "trigger": "Comparable", - "contents": "Comparable", "kind": ["type", "i", "Interface"] }, { "trigger": "Iterable", - "contents": "Iterable", "kind": ["type", "i", "Interface"] }, { "trigger": "Readable", - "contents": "Readable", "kind": ["type", "i", "Interface"] }, { "trigger": "Runnable", - "contents": "Runnable", "kind": ["type", "i", "Interface"] }, // "Thread.UncaughtExceptionHandler", @@ -303,175 +289,141 @@ // java.lang Classes { "trigger": "Boolean", - "contents": "Boolean", "kind": ["type", "c", "Class"] }, { "trigger": "Byte", - "contents": "Byte", "kind": ["type", "c", "Class"] }, { "trigger": "Character", - "contents": "Character", "kind": ["type", "c", "Class"] }, // "Character.Subset", // "Character.UnicodeBlock", { "trigger": "Class", - "contents": "Class", "kind": ["type", "c", "Class"] }, { "trigger": "ClassLoader", - "contents": "ClassLoader", "kind": ["type", "c", "Class"] }, { "trigger": "ClassValue", - "contents": "ClassValue", "kind": ["type", "c", "Class"] }, { "trigger": "Compiler", - "contents": "Compiler", "kind": ["type", "c", "Class"] }, { "trigger": "Double", - "contents": "Double", "kind": ["type", "c", "Class"] }, { "trigger": "Enum", - "contents": "Enum", "kind": ["type", "c", "Class"] }, { "trigger": "Float", - "contents": "Float", "kind": ["type", "c", "Class"] }, { "trigger": "InheritableThreadLocal", - "contents": "InheritableThreadLocal", "kind": ["type", "c", "Class"] }, { "trigger": "Integer", - "contents": "Integer", "kind": ["type", "c", "Class"] }, { "trigger": "Long", - "contents": "Long", "kind": ["type", "c", "Class"] }, { "trigger": "Math", - "contents": "Math", "kind": ["type", "c", "Class"] }, { "trigger": "Number", - "contents": "Number", "kind": ["type", "c", "Class"] }, { "trigger": "Object", - "contents": "Object", "kind": ["type", "c", "Class"] }, { "trigger": "Package", - "contents": "Package", "kind": ["type", "c", "Class"] }, { "trigger": "Process", - "contents": "Process", "kind": ["type", "c", "Class"] }, { "trigger": "ProcessBuilder", - "contents": "ProcessBuilder", "kind": ["type", "c", "Class"] }, // "ProcessBuilder.Redirect", { "trigger": "Runtime", - "contents": "Runtime", "kind": ["type", "c", "Class"] }, { "trigger": "RuntimePermission", - "contents": "RuntimePermission", "kind": ["type", "c", "Class"] }, { "trigger": "SecurityManager", - "contents": "SecurityManager", "kind": ["type", "c", "Class"] }, { "trigger": "Short", - "contents": "Short", "kind": ["type", "c", "Class"] }, { "trigger": "StackTraceElement", - "contents": "StackTraceElement", "kind": ["type", "c", "Class"] }, { "trigger": "StrictMath", - "contents": "StrictMath", "kind": ["type", "c", "Class"] }, { "trigger": "String", - "contents": "String", "kind": ["type", "c", "Class"] }, { "trigger": "StringBuffer", - "contents": "StringBuffer", "kind": ["type", "c", "Class"] }, { "trigger": "StringBuilder", - "contents": "StringBuilder", "kind": ["type", "c", "Class"] }, { "trigger": "System", - "contents": "System", "kind": ["type", "c", "Class"] }, { "trigger": "Thread", - "contents": "Thread", "kind": ["type", "c", "Class"] }, { "trigger": "ThreadGroup", - "contents": "ThreadGroup", "kind": ["type", "c", "Class"] }, { "trigger": "ThreadLocal", - "contents": "ThreadLocal", "kind": ["type", "c", "Class"] }, { "trigger": "Throwable", - "contents": "Throwable", "kind": ["type", "c", "Class"] }, { "trigger": "Void", - "contents": "Void", "kind": ["type", "c", "Class"] }, @@ -483,281 +435,226 @@ // java.lang Exceptions { "trigger": "ArithmeticException", - "contents": "ArithmeticException", "kind": ["type", "x", "Exception"] }, { "trigger": "ArrayIndexOutOfBoundsException", - "contents": "ArrayIndexOutOfBoundsException", "kind": ["type", "x", "Exception"] }, { "trigger": "ArrayStoreException", - "contents": "ArrayStoreException", "kind": ["type", "x", "Exception"] }, { "trigger": "ClassCastException", - "contents": "ClassCastException", "kind": ["type", "x", "Exception"] }, { "trigger": "ClassNotFoundException", - "contents": "ClassNotFoundException", "kind": ["type", "x", "Exception"] }, { "trigger": "CloneNotSupportedException", - "contents": "CloneNotSupportedException", "kind": ["type", "x", "Exception"] }, { "trigger": "EnumConstantNotPresentException", - "contents": "EnumConstantNotPresentException", "kind": ["type", "x", "Exception"] }, { "trigger": "Exception", - "contents": "Exception", "kind": ["type", "x", "Exception"] }, { "trigger": "IllegalAccessException", - "contents": "IllegalAccessException", "kind": ["type", "x", "Exception"] }, { "trigger": "IllegalArgumentException", - "contents": "IllegalArgumentException", "kind": ["type", "x", "Exception"] }, { "trigger": "IllegalMonitorStateException", - "contents": "IllegalMonitorStateException", "kind": ["type", "x", "Exception"] }, { "trigger": "IllegalStateException", - "contents": "IllegalStateException", "kind": ["type", "x", "Exception"] }, { "trigger": "IllegalThreadStateException", - "contents": "IllegalThreadStateException", "kind": ["type", "x", "Exception"] }, { "trigger": "IndexOutOfBoundsException", - "contents": "IndexOutOfBoundsException", "kind": ["type", "x", "Exception"] }, { "trigger": "InstantiationException", - "contents": "InstantiationException", "kind": ["type", "x", "Exception"] }, { "trigger": "InterruptedException", - "contents": "InterruptedException", "kind": ["type", "x", "Exception"] }, { "trigger": "NegativeArraySizeException", - "contents": "NegativeArraySizeException", "kind": ["type", "x", "Exception"] }, { "trigger": "NoSuchFieldException", - "contents": "NoSuchFieldException", "kind": ["type", "x", "Exception"] }, { "trigger": "NoSuchMethodException", - "contents": "NoSuchMethodException", "kind": ["type", "x", "Exception"] }, { "trigger": "NullPointerException", - "contents": "NullPointerException", "kind": ["type", "x", "Exception"] }, { "trigger": "NumberFormatException", - "contents": "NumberFormatException", "kind": ["type", "x", "Exception"] }, { "trigger": "ReflectiveOperationException", - "contents": "ReflectiveOperationException", "kind": ["type", "x", "Exception"] }, { "trigger": "RuntimeException", - "contents": "RuntimeException", "kind": ["type", "x", "Exception"] }, { "trigger": "SecurityException", - "contents": "SecurityException", "kind": ["type", "x", "Exception"] }, { "trigger": "StringIndexOutOfBoundsException", - "contents": "StringIndexOutOfBoundsException", "kind": ["type", "x", "Exception"] }, { "trigger": "TypeNotPresentException", - "contents": "TypeNotPresentException", "kind": ["type", "x", "Exception"] }, { "trigger": "UnsupportedOperationException", - "contents": "UnsupportedOperationException", "kind": ["type", "x", "Exception"] }, // java.lang Errors { "trigger": "AbstractMethodError", - "contents": "AbstractMethodError", "kind": ["type", "e", "Error"] }, { "trigger": "AssertionError", - "contents": "AssertionError", "kind": ["type", "e", "Error"] }, { "trigger": "BootstrapMethodError", - "contents": "BootstrapMethodError", "kind": ["type", "e", "Error"] }, { "trigger": "ClassCircularityError", - "contents": "ClassCircularityError", "kind": ["type", "e", "Error"] }, { "trigger": "ClassFormatError", - "contents": "ClassFormatError", "kind": ["type", "e", "Error"] }, { "trigger": "Error", - "contents": "Error", "kind": ["type", "e", "Error"] }, { "trigger": "ExceptionInInitializerError", - "contents": "ExceptionInInitializerError", "kind": ["type", "e", "Error"] }, { "trigger": "IllegalAccessError", - "contents": "IllegalAccessError", "kind": ["type", "e", "Error"] }, { "trigger": "IncompatibleClassChangeError", - "contents": "IncompatibleClassChangeError", "kind": ["type", "e", "Error"] }, { "trigger": "InstantiationError", - "contents": "InstantiationError", "kind": ["type", "e", "Error"] }, { "trigger": "InternalError", - "contents": "InternalError", "kind": ["type", "e", "Error"] }, { "trigger": "LinkageError", - "contents": "LinkageError", "kind": ["type", "e", "Error"] }, { "trigger": "NoClassDefFoundError", - "contents": "NoClassDefFoundError", "kind": ["type", "e", "Error"] }, { "trigger": "NoSuchFieldError", - "contents": "NoSuchFieldError", "kind": ["type", "e", "Error"] }, { "trigger": "NoSuchMethodError", - "contents": "NoSuchMethodError", "kind": ["type", "e", "Error"] }, { "trigger": "OutOfMemoryError", - "contents": "OutOfMemoryError", "kind": ["type", "e", "Error"] }, { "trigger": "StackOverflowError", - "contents": "StackOverflowError", "kind": ["type", "e", "Error"] }, { "trigger": "ThreadDeath", - "contents": "ThreadDeath", "kind": ["type", "e", "Error"] }, { "trigger": "UnknownError", - "contents": "UnknownError", "kind": ["type", "e", "Error"] }, { "trigger": "UnsatisfiedLinkError", - "contents": "UnsatisfiedLinkError", "kind": ["type", "e", "Error"] }, { "trigger": "UnsupportedClassVersionError", - "contents": "UnsupportedClassVersionError", "kind": ["type", "e", "Error"] }, { "trigger": "VerifyError", - "contents": "VerifyError", "kind": ["type", "e", "Error"] }, { "trigger": "VirtualMachineError", - "contents": "VirtualMachineError", "kind": ["type", "e", "Error"] }, // java.lang Annotations { "trigger": "Deprecated", - "contents": "Deprecated", "kind": ["function", "a", "Annotation"] }, { "trigger": "FunctionalInterface", - "contents": "FunctionalInterface", "kind": ["function", "a", "Annotation"] }, { "trigger": "Override", - "contents": "Override", "kind": ["function", "a", "Annotation"] }, { "trigger": "SafeVarargs", - "contents": "SafeVarargs", "kind": ["function", "a", "Annotation"] }, { "trigger": "SuppressWarnings", - "contents": "SuppressWarnings", "kind": ["function", "a", "Annotation"] }, @@ -767,217 +664,174 @@ // java.util.function Interfaces { "trigger": "BiConsumer", - "contents": "BiConsumer", "kind": ["type", "i", "Interface"] }, { "trigger": "BiFunction", - "contents": "BiFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "BinaryOperator", - "contents": "BinaryOperator", "kind": ["type", "i", "Interface"] }, { "trigger": "BiPredicate", - "contents": "BiPredicate", "kind": ["type", "i", "Interface"] }, { "trigger": "BooleanSupplier", - "contents": "BooleanSupplier", "kind": ["type", "i", "Interface"] }, { "trigger": "Consumer", - "contents": "Consumer", "kind": ["type", "i", "Interface"] }, { "trigger": "DoubleBinaryOperator", - "contents": "DoubleBinaryOperator", "kind": ["type", "i", "Interface"] }, { "trigger": "DoubleConsumer", - "contents": "DoubleConsumer", "kind": ["type", "i", "Interface"] }, { "trigger": "DoubleFunction", - "contents": "DoubleFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "DoublePredicate", - "contents": "DoublePredicate", "kind": ["type", "i", "Interface"] }, { "trigger": "DoubleSupplier", - "contents": "DoubleSupplier", "kind": ["type", "i", "Interface"] }, { "trigger": "DoubleToIntFunction", - "contents": "DoubleToIntFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "DoubleToLongFunction", - "contents": "DoubleToLongFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "DoubleUnaryOperator", - "contents": "DoubleUnaryOperator", "kind": ["type", "i", "Interface"] }, { "trigger": "Function", - "contents": "Function", "kind": ["type", "i", "Interface"] }, { "trigger": "IntBinaryOperator", - "contents": "IntBinaryOperator", "kind": ["type", "i", "Interface"] }, { "trigger": "IntConsumer", - "contents": "IntConsumer", "kind": ["type", "i", "Interface"] }, { "trigger": "IntFunction", - "contents": "IntFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "IntPredicate", - "contents": "IntPredicate", "kind": ["type", "i", "Interface"] }, { "trigger": "IntSupplier", - "contents": "IntSupplier", "kind": ["type", "i", "Interface"] }, { "trigger": "IntToDoubleFunction", - "contents": "IntToDoubleFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "IntToLongFunction", - "contents": "IntToLongFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "IntUnaryOperator", - "contents": "IntUnaryOperator", "kind": ["type", "i", "Interface"] }, { "trigger": "LongBinaryOperator", - "contents": "LongBinaryOperator", "kind": ["type", "i", "Interface"] }, { "trigger": "LongConsumer", - "contents": "LongConsumer", "kind": ["type", "i", "Interface"] }, { "trigger": "LongFunction", - "contents": "LongFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "LongPredicate", - "contents": "LongPredicate", "kind": ["type", "i", "Interface"] }, { "trigger": "LongSupplier", - "contents": "LongSupplier", "kind": ["type", "i", "Interface"] }, { "trigger": "LongToDoubleFunction", - "contents": "LongToDoubleFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "LongToIntFunction", - "contents": "LongToIntFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "LongUnaryOperator", - "contents": "LongUnaryOperator", "kind": ["type", "i", "Interface"] }, { "trigger": "ObjDoubleConsumer", - "contents": "ObjDoubleConsumer", "kind": ["type", "i", "Interface"] }, { "trigger": "ObjIntConsumer", - "contents": "ObjIntConsumer", "kind": ["type", "i", "Interface"] }, { "trigger": "ObjLongConsumer", - "contents": "ObjLongConsumer", "kind": ["type", "i", "Interface"] }, { "trigger": "Predicate", - "contents": "Predicate", "kind": ["type", "i", "Interface"] }, { "trigger": "Supplier", - "contents": "Supplier", "kind": ["type", "i", "Interface"] }, { "trigger": "ToDoubleBiFunction", - "contents": "ToDoubleBiFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "ToDoubleFunction", - "contents": "ToDoubleFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "ToIntBiFunction", - "contents": "ToIntBiFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "ToIntFunction", - "contents": "ToIntFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "ToLongBiFunction", - "contents": "ToLongBiFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "ToLongFunction", - "contents": "ToLongFunction", "kind": ["type", "i", "Interface"] }, { "trigger": "UnaryOperator", - "contents": "UnaryOperator", "kind": ["type", "i", "Interface"] }, ] diff --git a/Java/Java.sublime-settings b/Java/Java.sublime-settings new file mode 100644 index 0000000000..4d14cb762e --- /dev/null +++ b/Java/Java.sublime-settings @@ -0,0 +1,6 @@ +{ + "match_brackets_angle": true, + + // Default word boundaries except: $ + "word_separators": "./\\()\"'-:,.;<>~!@#%^&*|+=[]{}`~?" +} \ No newline at end of file diff --git a/Java/Java.sublime-syntax b/Java/Java.sublime-syntax index 39716286d9..6b5eab9692 100644 --- a/Java/Java.sublime-syntax +++ b/Java/Java.sublime-syntax @@ -1,8 +1,10 @@ %YAML 1.2 --- -# http://www.sublimetext.com/docs/3/syntax.html +# https://www.sublimetext.com/docs/syntax.html +# https://docs.oracle.com/javase/specs/jls/se13/html/index.html name: Java scope: source.java +version: 2 file_extensions: - java @@ -14,20 +16,91 @@ first_line_match: |- | ^ \s* // .*? -\*- .*? \bjava\b .*? -\*- # editorconfig ) -variables: - primitives: (?:boolean|byte|char|short|int|float|long|double) - storage_modifiers: (?:public|private|protected|static|final|native|synchronized|strictfp|abstract|transient|default|volatile) - - id: (?:[\p{L}_$][\p{L}\p{N}_$]*) - classcase_id: (?:\p{Lu}[\p{L}\p{N}_$]*) - lowercase_id: (?:[_$]*\p{Ll}[\p{Ll}\p{N}_$]*\b) - uppercase_id: (?:[_$]*\p{Lu}[\p{Lu}\p{N}_$]*\b) +############################################################################### - # One dot is mandatory to not compete with other regexes that match an id. - before_fqn: (?={{lowercase_id}}\s*\.) - - # utility lookaround - lambda_lookahead: (?:\(.*\)|{{id}})\s*-> +variables: + # Reserved keywords + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.9 + reserved_words: |- + (?x: + {{keywords}} + | {{storage_types}} + | {{storage_modifiers}} + | {{constants}} + | {{variables}} + ) + keywords: |- + (?x: + {{declaration_keywords}} + | {{control_keywords}} + | {{operator_keywords}} + | {{illegal_keywords}} + ) + declaration_keywords: |- + (?x: class | enum | @?interface | record | var | void | extends | implements | import | package ) + control_keywords: |- + (?x: assert | break | case | catch | continue | do | else | finally | for + | if | return | switch | throw | throws | try | while ) + operator_keywords: |- + (?x: new | instanceof ) + illegal_keywords: |- + (?x: const | goto ) + + # Storage Modifiers + storage_modifiers: |- + (?x: + {{class_modifier}} + | {{class_no_modifier}} + ) + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.1.1 + class_modifier: |- + (?x: public | protected | private | abstract | final | sealed | static | strictfp ) + class_no_modifier: |- + (?x: default | native | synchronized | transient | volatile ) + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.8 + constructor_modifier: |- + (?x: public | protected | private ) + constructor_no_modifier: |- + (?x: abstract | default | final | native | sealed | static | strictfp | synchronized | transient | volatile ) + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.3.1 + field_modifier: |- + (?x: public | protected | private | final | static | transient | volatile ) + field_no_modifier: |- + (?x: abstract | default | native | sealed | strictfp | synchronized ) + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-9.1.1 + interface_modifier: |- + (?x: public | protected | private | abstract | sealed | static | strictfp ) + interface_no_modifier: |- + (?x: default | final | native | synchronized | transient | volatile ) + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4.3 + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-9.html#jls-9.4 + method_modifier: |- + (?x: public | protected | private | abstract | default | final | native | static | strictfp | synchronized ) + method_no_modifier: |- + (?x: sealed | transient | volatile ) + + # Storage Types + storage_types: |- + (?x: boolean | byte | char | short | int | float | long | double ) + + # Literals + constants: |- + (?x: false | null | true ) + variables: |- + (?x: _ | super | this ) + + # Identifiers + break: (?!{{id_char}}) + + identifier: (?!{{reserved_words}}[^{{id_char}}]){{id}} + + id: (?:{{id_first_char}}{{id_char}}*) + id_first_char: '[\p{L}_$]' + id_char: '[\p{L}\p{N}_$]' + + classcase_id: (?:\p{Lu}{{id_char}}*) + lowercase_id: (?:[_$]*\p{Ll}[\p{Ll}\p{N}_$]*{{break}}) + uppercase_id: (?:[_$]*\p{Lu}[\p{Lu}\p{N}_$]*{{break}}) # digits bin_digit: '[01_]' @@ -36,1207 +109,3126 @@ variables: hex_digit: '[\h_]' dec_exponent: '[eE][-+]?{{dec_digit}}*' hex_exponent: '[pP][-+]?{{dec_digit}}*' + float_suffix: '[dDfF]{{break}}' + int_suffix: '[lL]{{break}}' -contexts: - prototype: - - match: (?=%>) - pop: true - - include: comments - - include: illegal-keywords + escape_octal: \\[0-3]?[0-7]{1,2} + escape_other: \\[btnfr"'\\] + escape_unicode: \\u+\h{4} - any_POP: - - match: (?=\S) - pop: true + # accessor but no variadic operator + single_dot: \.(?!\.) - immediate_POP: - - match: '' - pop: true +############################################################################### +contexts: main: - - include: prototype - - include: package-statement - - include: import-statement + - meta_include_prototype: false + - match: '' + push: [java, shebang] + + java: + - include: import - include: module - - include: class - - include: annotations - # Get modifiers defined on a different line than the class + - include: package + - include: statements + - include: declarations + - include: else-expressions + + statements: + - include: member-statements + - include: synchronized-statements + + member-statements: + - include: punctuation-terminator-semicolon + - include: blocks + - include: stray-group + - include: flow-control-statements + - include: if-else-statements + - include: switch-case-statements + - include: do-while-statements + - include: for-statements + - include: try-catch-statements + - include: labeled-statements + + expressions: + - include: groups + - include: literals + - include: punctuations + - include: lambdas + - include: operators + - include: instantiations + - include: primitive-types + - include: var-types + - include: array-modifiers - include: storage-modifiers - - include: stray-braces - - include: code + - include: object-types + - include: variables - punctuation-accessor-dot: - - match: \. - scope: punctuation.accessor.dot.java +###[ COMMENTS ]################################################################ - punctuation-separator-comma: - - match: \, - scope: punctuation.separator.comma.java + comments: + - include: line-comments + - include: block-comments - punctuation-terminator-semicolon: - - match: ; - scope: punctuation.terminator.java + block-comments: + # empty block comments + - match: /\*\*+/ + scope: comment.block.empty.java punctuation.definition.comment.java + # documentation block comments + - match: /\*\*+ + scope: + comment.block.documentation.java + punctuation.definition.comment.begin.java + embed: Packages/Java/JavaDoc.sublime-syntax#javadoc + embed_scope: comment.block.documentation.java + escape: \*+/ + escape_captures: + 0: comment.block.documentation.java + punctuation.definition.comment.end.java + # normal block comments + - match: /\* + scope: punctuation.definition.comment.begin.java + push: block-comment-body + + block-comment-body: + - meta_include_prototype: false + - meta_scope: comment.block.java + - match: \*+/ + scope: punctuation.definition.comment.end.java + pop: 1 + - match: ^\s*(\*)(?![*/]) + scope: punctuation.definition.comment.java - dot-separated-identifier: - - match: '{{id}}' - - include: punctuation-accessor-dot - - include: immediate_POP + line-comments: + - match: //+ + scope: punctuation.definition.comment.java + push: line-comment-body - package-statement: - - match: \bpackage\b - scope: keyword.other.package.java - push: - - - meta_scope: meta.package-declaration.java - - include: immediate_POP - - - match: '{{id}}' - set: - - meta_scope: meta.path.java entity.name.namespace.java - - include: dot-separated-identifier - - include: any_POP - - import-statement: - - match: \bimport\b - scope: keyword.control.import.java - push: - - - meta_scope: meta.import.java - - include: immediate_POP - - import-statement-body - - import-statement-body: - - match: \bstatic\b - scope: keyword.control.import.static.java - set: static-import-statement-body - - include: before-next-import - - match: '{{lowercase_id}}' - scope: meta.path.java support.type.package.java + line-comment-body: + - meta_include_prototype: false + - meta_scope: comment.line.double-slash.java + - match: (//+)?\n + captures: + 1: punctuation.definition.comment.java + pop: 1 + + shebang: + - meta_include_prototype: false + - match: ^\#! + scope: punctuation.definition.comment.java + set: shebang-body + - match: ^|(?=\S) # Note: Ensure to highlight shebang if Erlang is embedded. + pop: 1 + + shebang-body: + - meta_include_prototype: false + - meta_scope: comment.line.shebang.java + # Note: Keep sync with first_line_match! + - match: \b(bsh|java)\b + scope: constant.language.shebang.java + - match: \n + pop: 1 + +###[ ANNOTATIONS ]############################################################# + + annotations: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-9.html#jls-9.7 + - match: \@(?!interface{{break}}) + scope: punctuation.definition.annotation.java + branch_point: annotation-identifier + branch: + - annotation-unqualified-identifier + - annotation-qualified-identifier + + annotation-unqualified-identifier: + - meta_scope: meta.annotation.identifier.java + - match: '{{identifier}}' + scope: variable.annotation.java + branch_point: annotation-unqualified-parameters + branch: + - annotation-unqualified-parameters + - immediately-pop2 + - include: else-pop + + annotation-unqualified-parameters: + - match: \( + scope: punctuation.section.group.begin.java + pop: 2 + push: annotation-parameters-body + # fail: looks like a qualified annotation + - match: (?={{single_dot}}) + fail: annotation-identifier + # fail: truncate meta scope immediatelly + - match: (?=\S) + fail: annotation-unqualified-parameters + + annotation-qualified-identifier: + - meta_include_prototype: false + - meta_scope: meta.annotation.identifier.java meta.path.java + - match: '' + branch_point: annotation-qualified-identifier + branch: + - annotation-qualified-identifier-path + - annotation-qualified-identifier-name + + annotation-qualified-identifier-path: + - match: '{{identifier}}' + scope: variable.annotation.namespace.java + set: annotation-qualified-identifier-accessor + - include: else-pop2 + + annotation-qualified-identifier-accessor: + - include: punctuation-accessor-dot-pop + - match: (?=\S) + fail: annotation-qualified-identifier + + annotation-qualified-identifier-name: + - match: '{{identifier}}' + scope: + meta.annotation.identifier.java meta.path.java + variable.annotation.java + pop: 2 + branch_point: annotation-qualified-parameters + branch: + - annotation-qualified-parameters + - immediately-pop + - include: else-pop2 + + annotation-qualified-parameters: + - meta_content_scope: meta.annotation.identifier.java + - match: \( + scope: punctuation.section.group.begin.java + set: annotation-parameters-body + - match: (?=\S) + fail: annotation-qualified-parameters + + annotation-parameters-body: + - meta_scope: meta.annotation.parameters.java meta.group.java + - include: group-end + - match: (?={{id_first_char}}) + branch_point: annotation-parameter + branch: + - annotation-parameter + - expression + - include: variable-initializers + + annotation-parameter: + - match: '{{identifier}}' + scope: variable.parameter.java + set: annotation-parameter-assignment + - match: '' + fail: annotation-parameter + + annotation-parameter-assignment: + - match: = + scope: keyword.operator.assignment.java + set: variable-initializer + - match: (?=\S) + fail: annotation-parameter + +###[ DECLARATIONS ]############################################################ + + declarations: + # As per specification separate declarations for globals, members, and + # locals are needed, as each of them supports only a subset of declaration + # statements: + # - globals: class, enum, interface + # - members: class, enum, interface, constructor, field, method + # - locals: class, variables + # - try/for: variables + # + # Member declarations need to be handled differently as constructurs look + # exactly like function calls. The other two scopes (global, local) are + # merged here to maintain syntax highlighting whenever possible. That's + # needed for `incomplete code` scenarios or if contexts are lost due to + # embedding Java into JSP. + - match: (?=[{{id_first_char}}@<]) + branch_point: declarations + branch: + - declaration-maybe-class + - declaration-maybe-enum + - declaration-maybe-interface + - declaration-maybe-variable + - declaration-maybe-method + + declaration-else-fail: + - match: (?=\S) + fail: declarations + + declaration-maybe-class: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.1 + - meta_scope: meta.class.java + - include: class-keyword + - include: record-keyword + - include: class-modifiers + - include: declaration-else-fail + + declaration-maybe-enum: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.9 + # Note: Local enum declarations are not valid, + # but may help maintaining highlighting in incomplete code. + - meta_scope: meta.enum.java + - include: enum-keyword + - include: class-modifiers + - include: declaration-else-fail + + declaration-maybe-interface: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-9.html#jls-9.1 + # Note: Local interface declarations are not valid, + # but may help maintaining highlighting in incomplete code. + - meta_scope: meta.interface.java + - include: interface-keyword + - include: interface-modifiers + - include: declaration-else-fail + + declaration-maybe-method: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4 + - meta_include_prototype: false + - match: '' set: - - meta_content_scope: meta.path.java - - include: before-next-import - - include: package - - match: \* - scope: meta.path.java keyword.operator.wildcard.asterisk.java - pop: true - - match: '{{classcase_id}}' - scope: support.class.import.java - set: - - include: before-next-import - - include: punctuation-accessor-dot - - include: import-class - - include: import-wildcard - - include: any_POP - - include: any_POP - - include: any_POP - - static-import-statement-body: - - include: before-next-import - - match: '{{lowercase_id}}' - scope: meta.path.java support.type.package.java + - method-block + - method-attributes + - method-array-modifiers + - declaration-method-signature + - method-modifier + + declaration-method-signature: + - include: method-void-signature + - match: (?=\S) set: - - meta_content_scope: meta.path.java - - include: before-next-import - - include: package - - match: '{{classcase_id}}' - scope: support.class.import.java - set: - - include: before-next-import - - include: punctuation-accessor-dot - - include: import-constant - - include: import-class - - include: import-function - - include: import-wildcard - - include: any_POP - - include: any_POP - - include: any_POP - - before-next-import: - # Prevent next import statement to be consumed when a current statement isn't terminated with ';'. - - match: (?=\bimport\b) - pop: true - # For a case of a statement immediately before a class definition. - - match: (?=\b(?:{{storage_modifiers}}|class|interface|enum)\b) - pop: true + - declaration-method-expect-parameters + - declaration-method-expect-identifier + - method-result-modifier + - method-result-type + + declaration-method-expect-identifier: + - include: method-identifier + - include: declaration-else-fail + + declaration-method-expect-parameters: + - meta_content_scope: meta.function.identifier.java + - include: method-parameters + - include: declaration-else-fail + + declaration-maybe-variable: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.4 + - meta_include_prototype: false + - match: '' + set: + - variable-declaration-list + - variable-declaration-value-assignment + - variable-declaration-expect-identifier + - variable-declaration-type-modifier + - variable-declaration-type + +###[ PACKAGE DECLARATIONS ]#################################################### package: - - match: '{{lowercase_id}}' - scope: support.type.package.java - - include: punctuation-accessor-dot + - match: package{{break}} + scope: keyword.declaration.namespace.package.java + push: + - meta_scope: meta.namespace.package.java + - match: (?=\S) + set: package-identifier - all-types: - - include: primitive-types - - include: object-types + package-identifier: + - meta_include_prototype: false + - meta_content_scope: meta.namespace.package.identifier.java + - include: entity-package + - include: immediately-pop - import-constant: - - match: '{{uppercase_id}}' - scope: constant.other.import.java +###[ MODULE DECLARATIONS ]##################################################### - import-class: - - match: '{{classcase_id}}' - scope: support.class.import.java + module: + - match: (?:(open)\s+)?(module){{break}} + captures: + 1: storage.modifier.java + 2: keyword.declaration.namespace.module.java + push: + - meta_scope: meta.namespace.module.java + - match: (?=\S) + set: + - module-block + - module-identifier - import-function: - - match: '{{id}}' - scope: support.function.import.java + module-identifier: + - meta_include_prototype: false + - include: entity-module + - include: immediately-pop - import-wildcard: - - match: \* - scope: keyword.operator.wildcard.asterisk.java + module-block: + - meta_content_scope: meta.namespace.module.identifier.java + - match: \{ + scope: punctuation.section.block.begin.java + set: module-block-body + - include: else-pop - annotations: - - match: \@ - scope: punctuation.definition.annotation.java + module-block-body: + - meta_scope: meta.namespace.module.java meta.block.java + - include: block-end + - include: punctuation-terminator-semicolon + - match: exports{{break}} + scope: keyword.other.module.exports.java push: - - - meta_scope: meta.annotation.java - - include: immediate_POP - - annotation-parameters - - - meta_content_scope: meta.annotation.identifier.java - - include: immediate_POP - - annotation-type-reference - - annotation-type-reference: - - match: '{{before_fqn}}' - set: - - meta_scope: meta.path.java - - match: '{{lowercase_id}}' - scope: variable.annotation.package.java - - include: punctuation-accessor-dot - - include: annotation-type-no-fqn - - include: annotation-type-no-fqn + - module-exports-meta + - module-exports-or-opens-body + - match: opens{{break}} + scope: keyword.other.module.opens.java + push: + - module-opens-meta + - module-exports-or-opens-body + - match: requires{{break}} + scope: keyword.other.module.requires.java + push: module-requires-body + - match: uses{{break}} + scope: keyword.other.module.uses.java + push: + - module-uses-meta + - module-provides-or-uses-body + - match: provides{{break}} + scope: keyword.other.module.provides.java + push: + - module-provides-meta + - module-provides-or-uses-body - annotation-type-no-fqn: - - match: '{{classcase_id}}' - scope: variable.annotation.java - set: after-annotation-type-reference - - include: any_POP + module-exports-meta: + - meta_include_prototype: false + - meta_scope: meta.exports.java + - include: immediately-pop - after-annotation-type-reference: - - match: \. - scope: punctuation.accessor.dot.java - set: annotation-type-no-fqn - - include: any_POP + module-opens-meta: + - meta_include_prototype: false + - meta_scope: meta.opens.java + - include: immediately-pop - annotation-parameters: - - match: \( - scope: punctuation.section.parens.begin.java + module-exports-or-opens-body: + - include: module-statement-terminator + - match: to{{break}} + scope: keyword.other.module.to.java set: - - meta_scope: meta.annotation.parameters.java - - match: \) - scope: punctuation.section.parens.end.java - pop: true - - match: ({{id}})\s*(=) - captures: - 1: variable.parameter.java - 2: keyword.operator.assignment.java - push: - - match: (?=[,})]) - pop: true - - include: annotations - - include: code - - include: annotation-array-initialization - - include: annotations - - include: code - - include: any_POP - - annotation-array-initialization: - - match: \{ - scope: punctuation.section.braces.begin.java - push: - - meta_scope: meta.braces.annotation-array-initialization.java - - include: array-initialization-common - - include: annotations + - include: module-statement-terminator + - include: punctuation-separator-comma + - include: entity-module + - include: entity-package - anonymous-classes-and-new: - - match: \bnew\b - scope: keyword.other.storage.new.java - push: - - - meta_scope: meta.instantiation.java - - include: immediate_POP - - instantiation + module-requires-body: + - meta_scope: meta.requires.java + - match: transitive{{break}} + scope: keyword.other.module.transitive.java + - include: module-statement-terminator + - include: entity-module - instantiation: - - match: \b{{primitives}}\b - scope: storage.type.primitive.java - set: array-definition - - match: '{{before_fqn}}' - set: [after-object-type-in-instantiation, object-type-fqn] - - include: object-type-instantiation-no-fqn + module-uses-meta: + - meta_include_prototype: false + - meta_scope: meta.uses.java + - include: immediately-pop - object-type-instantiation-no-fqn: - - match: '{{classcase_id}}' - scope: support.class.java - set: after-object-type-in-instantiation - - include: any_POP + module-provides-meta: + - meta_include_prototype: false + - meta_scope: meta.provides.java + - include: immediately-pop - after-object-type-in-instantiation: - - match: (?=\[) - set: array-definition - - match: (?=\() - set: object-construction - - match: <> - scope: punctuation.definition.generic.diamond.java - set: object-construction - - match: (?=<) - set: [after-generic-in-instantiation, generic-type-invocation] - - match: \. - scope: punctuation.accessor.dot.java - set: object-type-instantiation-no-fqn - - include: any_POP + module-provides-or-uses-body: + - include: module-statement-terminator + - match: with{{break}} + scope: keyword.other.module.with.java + set: + - include: module-statement-terminator + - include: punctuation-separator-comma + - include: entity-class + - include: entity-class - after-generic-in-instantiation: - - match: (?=\[) - set: array-definition - - include: object-construction + module-statement-terminator: + - match: (?=[;}]|(?:exports|opens|requires|provides|uses|{{reserved_words}}){{break}}) + pop: 1 - object-construction: - - match: \( - scope: punctuation.section.parens.begin.java - set: - - meta_scope: meta.parens.constructor-arguments.java - - match: \) - scope: punctuation.section.parens.end.java - set: - - match: \{ - scope: punctuation.section.braces.begin.java - set: - - meta_scope: meta.class.body.anonymous.java - - match: \} - scope: punctuation.section.braces.end.java - pop: true - - include: class-body - - include: any_POP - - include: illegal-parens-terminators - - include: code - - include: any_POP - - array-definition: - - match: \[ - scope: punctuation.section.brackets.begin.java +###[ IMPORT DECLARATIONS ]##################################################### + + import: + - match: import{{break}} + scope: keyword.declaration.import.java + push: import-modifier + + import-modifier: + - meta_scope: meta.import.java + - match: static{{break}} + scope: storage.modifier.java set: - - meta_scope: meta.brackets.array-initialization.java - - match: \] - scope: punctuation.section.brackets.end.java - set: - - match: (?=\[) - set: array-definition - - match: \{ - scope: punctuation.section.braces.begin.java - set: array-initialization - - include: any_POP - - include: code - - include: any_POP - - array-initialization: - - meta_scope: meta.braces.array-initialization.java - - include: array-initialization-common - - array-initialization-common: - - match: \} - scope: punctuation.section.braces.end.java - pop: true - - match: \{ - scope: punctuation.section.braces.begin.java - push: array-initialization - - include: code + - meta_content_scope: meta.import.java + - match: (?=\S) + set: import-static-namespace + - match: (?=\S) + set: import-normal-namespace - class: - - match: (?=({{storage_modifiers}}\s+)*(?:class|(?:@)?interface|enum)\b) - push: [class-meta, class-type] + import-normal-namespace: + - meta_content_scope: meta.import.java meta.path.java + - include: import-terminator + - include: import-package-name + - match: (?=\S) + set: import-normal-class + + import-normal-class: + - meta_content_scope: meta.import.java meta.path.java + - include: import-terminator + - include: import-class-name + - include: import-wildcard + - include: else-pop + + import-static-namespace: + - meta_content_scope: meta.import.java meta.path.java + - include: import-terminator + - include: import-package-name + - match: (?=\S) + set: import-static-class + + import-static-class: + - meta_content_scope: meta.import.java meta.path.java + - include: import-terminator + - include: import-constant-name + - include: import-class-path + - include: import-function-name + - include: import-wildcard + - include: else-pop + + import-constant-name: + - match: '{{uppercase_id}}(?!\s*\.)' + scope: + meta.import.java meta.path.java + entity.name.constant.java + set: import-expect-terminator + + import-package-name: + - match: '{{lowercase_id}}' + scope: variable.namespace.java + push: import-acessor-or-termintor + - include: punctuation-accessor-dot - class-meta: - - meta_scope: meta.class.java - - include: immediate_POP + import-class-path: + - match: '{{classcase_id}}' + scope: storage.type.class.java + push: import-acessor-or-termintor + - include: punctuation-accessor-dot - class-type: - - include: storage-modifiers - - match: (?:class|(\@?)interface)\b - scope: storage.type.java - captures: - 1: punctuation.definition.type.java + import-class-name: + - match: '{{classcase_id}}' + scope: entity.name.class.java + push: import-acessor-or-termintor + - include: punctuation-accessor-dot + + import-function-name: + - match: '{{identifier}}' + scope: + meta.import.java meta.path.java + entity.name.function.java + set: import-expect-terminator + + import-wildcard: + - match: \* + scope: + meta.import.java meta.path.java + variable.language.wildcard.asterisk.java + set: import-expect-terminator + + import-acessor-or-termintor: + # continue with the import context + - include: punctuation-accessor-dot-pop + # pop the import context + - match: (?=\s*;|\S) + pop: 2 + + import-expect-terminator: + - include: import-terminator + - match: \S + scope: invalid.illegal.expect-semicolon.java + + import-terminator: + - match: (?=\s*;|{{reserved_words}}{{break}}) + pop: 1 + +###[ CLASS DECLARATIONS ]###################################################### + + class-keyword: + - match: class{{break}} + scope: keyword.declaration.class.java set: - class-block - class-extends - - generic-type-declaration + - class-name-meta + - maybe-type-parameter - class-name - - match: enum\b - scope: storage.type.java - set: - - enum-block - - class-extends - - generic-type-declaration - - class-name - - include: any_POP + + class-modifiers: + - match: '{{class_modifier}}{{break}}' + scope: storage.modifier.java + - match: '{{class_no_modifier}}{{break}}' + scope: invalid.illegal.unexpected-keyword.java + - include: annotations class-name: - - meta_scope: meta.class.identifier.java - - match: (?!extends|implements){{id}}\b + - match: '{{identifier}}' scope: entity.name.class.java - pop: true - - include: any_POP + pop: 1 + - include: else-pop + + class-name-meta: + - meta_content_scope: meta.class.identifier.java + - include: else-pop class-extends: - - match: extends\b - scope: keyword.declaration.extends.java + - match: extends{{break}} + scope: storage.modifier.extends.java push: - - - meta_scope: meta.class.extends.java - - match: \, - scope: punctuation.separator.comma.java - push: inherited-object-type-reference - - include: any_POP - - inherited-object-type-reference - - match: implements\b - scope: keyword.declaration.implements.java + - class-extends-object-type-list + - inherited-object-type + - match: implements{{break}} + scope: storage.modifier.implements.java push: - - - meta_scope: meta.class.implements.java - - match: \, - scope: punctuation.separator.comma.java - push: inherited-object-type-reference - - include: any_POP - - inherited-object-type-reference - - include: any_POP + - class-implements-object-type-list + - inherited-object-type + - match: permits{{break}} + scope: storage.modifier.permits.java + push: + - class-permits-object-type-list + - inherited-object-type + - include: else-pop + + class-extends-object-type-list: + - meta_scope: meta.class.extends.java + - include: inherited-object-type-list + - include: else-pop + + class-implements-object-type-list: + - meta_scope: meta.class.implements.java + - include: inherited-object-type-list + - include: else-pop + + class-permits-object-type-list: + - meta_scope: meta.class.permits.java + - include: inherited-object-type-list + - include: else-pop class-block: - match: \{ scope: punctuation.section.block.begin.java + set: class-block-body + - include: else-pop + + class-block-body: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.1.6 + - meta_scope: meta.class.java meta.block.java + - include: block-end + - include: member-statements + - include: member-declarations + - include: else-expressions + +###[ ENUM DECLARATIONS ]####################################################### + + enum-keyword: + - match: enum{{break}} + scope: keyword.declaration.enum.java set: - - meta_scope: meta.class.body.java meta.block.java - - match: \} - scope: punctuation.section.block.end.java - pop: true - - include: class-body - - include: any_POP - - class-body: - - include: class - - include: annotations - - include: fields-and-methods - - include: constants-and-special-vars - - include: storage-modifiers - - include: all-types - - include: static-code-block - - include: punctuation-separator-comma - - include: punctuation-terminator-semicolon - - match: (?=<) - push: generic-type-declaration + - enum-block + - enum-extends + - enum-name-meta + - maybe-illegal-type-parameter + - enum-name + + enum-name: + - match: '{{identifier}}' + scope: entity.name.enum.java + pop: 1 + - include: else-pop + + enum-name-meta: + - meta_content_scope: meta.enum.identifier.java + - include: else-pop + + enum-extends: + - match: extends{{break}} + scope: invalid.illegal.unexpected-keyword.java + push: + - enum-extends-object-type-list + - inherited-object-type + - match: implements{{break}} + scope: storage.modifier.implements.java + push: + - enum-implements-object-type-list + - inherited-object-type + - match: permits{{break}} + scope: invalid.illegal.unexpected-keyword.java + push: + - enum-permits-object-type-list + - inherited-object-type + - include: else-pop + + enum-extends-object-type-list: + - meta_scope: meta.enum.extends.java + - include: inherited-object-type-list + - include: else-pop + + enum-implements-object-type-list: + - meta_scope: meta.enum.implements.java + - include: inherited-object-type-list + - include: else-pop + + enum-permits-object-type-list: + - meta_scope: meta.enum.permits.java + - include: inherited-object-type-list + - include: else-pop enum-block: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.9.1 - match: \{ scope: punctuation.section.block.begin.java set: - - meta_scope: meta.class.body.java meta.block.java - - match: \} - scope: punctuation.section.block.end.java - pop: true - - include: enum-body - - include: any_POP - - enum-body: - - match: ^(?=\s*([[:upper:]_][[:upper:][:digit:]_]*|(?!{{primitives}}|{{storage_modifiers}})[[:lower:]_][[:alnum:]_]*)\s*[,;{(]) - push: - - match: (?=[;}]) - pop: true - - match: \w+ - scope: constant.other.enum.java - push: - - meta_scope: meta.enum.java - - match: \{ - scope: punctuation.section.block.begin.java - push: - - meta_scope: meta.enum.body.java meta.block.java - - match: \} - scope: punctuation.section.block.end.java - pop: true - - include: enum-body - - include: parens - - include: any_POP - - include: punctuation-separator-comma - - include: class-body + - enum-block-body + - enum-constants-list + - include: else-pop + + enum-block-body: + - meta_scope: meta.enum.java meta.block.java + - include: class-block-body + + enum-constants-list: + - meta_content_scope: meta.sequence.constants.java + - match: '{{identifier}}' + scope: meta.constant.identifier.java entity.name.constant.java + push: enum-constant-arguments + - include: punctuation-separator-comma + - include: else-pop - code: - - include: constants-and-special-vars - - include: assignment - - include: lambdas - - include: strings - - include: anonymous-classes-and-new - - include: keywords-control - - include: method-invocations - - include: uppercase-identifiers - - include: all-types - - include: keywords - - include: code-block-include - - include: parens - code-block-include: + enum-constant-arguments: + - meta_content_scope: meta.constant.identifier.java + - match: \( + scope: punctuation.section.group.begin.java + set: + - enum-constant-block + - enum-constant-arguments-body + - include: enum-constant-block + + enum-constant-arguments-body: + - clear_scopes: 1 + - meta_scope: meta.constant.arguments.java meta.group.java + - include: group-body + + enum-constant-block: + - meta_content_scope: meta.constant.java - match: \{ scope: punctuation.section.block.begin.java - push: - - meta_scope: meta.block.java - - match: \} - scope: punctuation.section.block.end.java - pop: true - - include: code-block - code-block: - - include: storage-modifiers - - include: var-type - - include: code + set: enum-constant-block-body + - include: else-pop + + enum-constant-block-body: + - meta_scope: meta.constant.java meta.block.java + - include: class-block-body + +###[ INTERFACE DECLARATIONS ]################################################## + + interface-keyword: + - match: (@?)interface{{break}} + scope: keyword.declaration.interface.java + set: + - interface-block + - interface-extends + - interface-name-meta + - maybe-type-parameter + - interface-name + + interface-modifiers: + - match: '{{interface_modifier}}{{break}}' + scope: storage.modifier.java + - match: '{{interface_no_modifier}}{{break}}' + scope: invalid.illegal.unexpected-keyword.java - include: annotations - - include: code-block-include - - include: stray-parens - comments: - - match: /\*\*/ - scope: comment.block.empty.java punctuation.definition.comment.java - - include: scope:text.html.javadoc - - include: comments-inline - comments-inline: - - match: /\* - scope: punctuation.definition.comment.java + + interface-name: + - match: '{{identifier}}' + scope: entity.name.interface.java + pop: 1 + - include: else-pop + + interface-name-meta: + - meta_content_scope: meta.interface.identifier.java + - include: else-pop + + interface-extends: + - match: extends{{break}} + scope: storage.modifier.extends.java push: - - meta_scope: comment.block.java - - match: \*/ - scope: punctuation.definition.comment.java - pop: true - - match: // - scope: punctuation.definition.comment.java + - interface-extends-object-type-list + - inherited-object-type + - match: implements{{break}} + scope: invalid.illegal.unexpected-keyword.java push: - - meta_scope: comment.line.double-slash.java - - match: \n - pop: true - - match: (?=%>) - pop: true - - constants-and-special-vars: - - match: \b(true|false|null)\b - scope: constant.language.java - - match: \b(this|super)\b - scope: variable.language.java - # hexadecimal floats - - match: |- - (?x) - \b(0[xX]) - ( - # 0x1., 0x1.1, 0x1.1p1, 0x1.1p-1, 0x1.p1, 0x1.p-1 | 0x1p1 - {{hex_digit}}* (?: (\.) {{hex_digit}}* (?:{{hex_exponent}})? | {{hex_exponent}} ) - # 0x.1, 0x.1p1, 0x.1p-1 - | (\.) {{hex_digit}}+ (?:{{hex_exponent}})? - ) - scope: meta.number.float.hexadecimal.java - captures: - 1: constant.numeric.base.java - 2: constant.numeric.value.java - 3: punctuation.separator.decimal.java - 4: punctuation.separator.decimal.java - # decimal floats - - match: |- - (?x) - \b([0-9]{{dec_digit}}*) - (?: - # 1., 1.1, 1.1e1, 1.1e-1, 1.e1, 1.e-1, 1.d, 1.1d, 1.1e1d, 1.1e-1d, 1.e1d, 1.e-1d - ( (\.) {{dec_digit}}* (?:{{dec_exponent}})? ) ([dDfF]\b)? - # 1e1 1e1d - | ({{dec_exponent}}) ([dDfF]\b)? - # 1d - | ([dDfF]\b) - ) - | ( (\.) {{dec_digit}}+ (?:{{dec_exponent}})? ) ([dDfF]\b)? - scope: meta.number.float.decimal.java - captures: - 1: constant.numeric.value.java - 2: constant.numeric.value.java - 3: punctuation.separator.decimal.java - 4: constant.numeric.suffix.java - 5: constant.numeric.value.java - 6: constant.numeric.suffix.java - 7: constant.numeric.suffix.java - 8: constant.numeric.value.java - 9: punctuation.separator.decimal.java - 10: constant.numeric.suffix.java - # binary integers - - match: \b(0[bB])({{bin_digit}}*)([lL]\b)? - scope: meta.number.integer.binary.java - captures: - 1: constant.numeric.base.java - 2: constant.numeric.value.java - 3: constant.numeric.suffix.java - # hexadecimal integers - - match: \b(0[xX])({{hex_digit}}*)([lL]\b)? - scope: meta.number.integer.hexadecimal.java - captures: - 1: constant.numeric.base.java - 2: constant.numeric.value.java + - interface-implements-object-type-list + - inherited-object-type + - match: permits{{break}} + scope: storage.modifier.permits.java + push: + - interface-permits-object-type-list + - inherited-object-type + - include: else-pop + + interface-extends-object-type-list: + - meta_scope: meta.interface.extends.java + - include: inherited-object-type-list + - include: else-pop + + interface-implements-object-type-list: + - meta_scope: meta.interface.implements.java + - include: inherited-object-type-list + - include: else-pop + + interface-permits-object-type-list: + - meta_scope: meta.interface.permits.java + - include: inherited-object-type-list + - include: else-pop + + interface-block: + - match: \{ + scope: punctuation.section.block.begin.java + set: interface-block-body + - include: else-pop + + interface-block-body: + - meta_scope: meta.interface.java meta.block.java + - include: class-block-body + +###[ RECORD DECLARATIONS ]##################################################### + + record-keyword: + # https://docs.oracle.com/javase/specs/jls/se16/html/jls-8.html#jls-8.10 + - match: record{{break}} + scope: keyword.declaration.record.java + set: + - class-block + - record-extends + - record-parameters + - maybe-type-parameter + - class-name + + record-parameters: + - meta_content_scope: meta.class.identifier.java + - match: \( + scope: punctuation.section.group.begin.java + set: + - record-parameter-body + - parameter-maybe-identifier + - parameter-maybe-variadic + - maybe-array-modifiers + - parameter-type + - include: else-pop + + record-parameter-body: + - meta_scope: meta.class.parameters.java meta.group.java + - match: \) + scope: punctuation.section.group.end.java + set: + - meta_content_scope: meta.class.java + - include: else-pop + - include: method-parameters-body + + record-extends: + - match: extends{{break}} + scope: invalid.illegal.unexpected-keyword.java + push: + - class-extends-object-type-list + - inherited-object-type + - match: implements{{break}} + scope: storage.modifier.implements.java + push: + - class-implements-object-type-list + - inherited-object-type + - match: permits{{break}} + scope: invalid.illegal.unexpected-keyword.java + push: + - class-permits-object-type-list + - inherited-object-type + - include: else-pop + +###[ MEMBER DECLARATIONS ]##################################################### + + member-declarations: + - match: (?=[{{id_first_char}}@<]) + branch_point: class-members + branch: + - member-maybe-constructor + - member-maybe-method + - member-maybe-field + - member-maybe-class + - member-maybe-enum + - member-maybe-interface + + member-else-fail: + - match: (?=\S) + fail: class-members + + member-reserved-fail: + - match: (?={{reserved_words}}{{break}}) + fail: class-members + + member-maybe-class: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.1 + - meta_scope: meta.class.java + - include: class-keyword + - include: record-keyword + - include: class-modifiers + - include: member-else-fail + + member-maybe-enum: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.9 + - meta_scope: meta.enum.java + - include: enum-keyword + - include: class-modifiers + - include: member-else-fail + + member-maybe-interface: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-9.html#jls-9.1 + - meta_scope: meta.interface.java + - include: interface-keyword + - include: interface-modifiers + - include: member-else-fail + + member-maybe-field: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.3 + - meta_include_prototype: false + - match: '' + set: + - field-identifier-list + - field-value-assignment + - field-identifier + - field-type-modifier + - field-type + - field-modifier + + member-maybe-constructor: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.8 + - meta_include_prototype: false + - match: '' + set: + - method-block + - method-attributes + - method-array-modifiers + - method-expect-parameters + - constructor-name + - method-modifier + + member-maybe-method: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4 + - meta_include_prototype: false + - match: '' + set: + - method-block + - method-attributes + - method-array-modifiers + - method-signature + - method-modifier + +###[ FIELD DECLARATIONS ]###################################################### + + field-modifier: + - clear_scopes: 1 + - meta_scope: meta.field.modifier.java + - match: '{{field_modifier}}{{break}}' + scope: storage.modifier.java + - match: '{{field_no_modifier}}{{break}}' + scope: invalid.illegal.unexpected-keyword.java + - include: type-parameters + - include: annotation-else-pop + + field-type: + - include: primitive-type + - include: object-type + - include: illegal-var-type + - include: member-else-fail + + field-type-modifier: + - clear_scopes: 1 + - meta_scope: meta.field.type.java + - include: array-modifiers + - include: annotations + - match: (?=[{(]|{{declaration_keywords}}{{break}}) + fail: class-members + - include: else-pop + + field-identifier-list: + - match: ',' + scope: + meta.field.java + punctuation.separator.comma.java + push: + - field-value-assignment + - field-identifier + - include: else-pop + + field-identifier: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-VariableDeclaratorId + - match: '{{uppercase_id}}' + scope: entity.name.constant.java + pop: 1 + - match: '{{identifier}}' + scope: variable.other.member.java + pop: 1 + - match: '{{variables}}{{break}}' + scope: invalid.illegal.identifier.java + pop: 1 + - include: else-pop + + field-value-assignment: + - meta_content_scope: meta.field.identifier.java + - match: = + scope: + meta.field.java + keyword.operator.assignment.java + set: field-value-initializer + - include: maybe-only-array-modifiers + + field-value-initializer: + - meta_content_scope: meta.field.value.java + - include: variable-initializer + +###[ METHOD DECLARATIONS ]##################################################### + + constructor-name: + - include: member-reserved-fail + - match: '{{id}}' + scope: entity.name.function.constructor.java + pop: 1 + - include: else-pop + + method-modifier: + - meta_scope: meta.function.modifier.java + - match: '{{method_modifier}}{{break}}' + scope: storage.modifier.java + - match: '{{method_no_modifier}}{{break}}' + scope: invalid.illegal.unexpected-keyword.java + - include: type-parameters + - include: annotation-else-pop + + method-signature: + - include: method-void-signature + - include: method-result-signature + + method-void-signature: + # void indicates a method for sure + - match: (?=void{{break}}) + set: + - method-maybe-parameters + - method-maybe-identifier + - method-result-modifier + - method-void-type + + method-void-type: + - match: void + scope: storage.type.void.java + pop: 1 + + method-result-signature: + # a method only if parameter list found + - match: (?=\S) + set: + - method-expect-parameters + - method-expect-identifier + - method-result-modifier + - method-result-type + + method-result-type: + - include: primitive-type + - include: object-type + - include: illegal-var-type + - include: else-pop + + method-result-modifier: + - clear_scopes: 1 + - meta_scope: meta.function.return-type.java + - include: maybe-array-modifiers + + method-expect-identifier: + - include: method-identifier + - include: member-else-fail + + method-maybe-identifier: + - include: method-identifier + - include: else-pop + + method-identifier: + - match: '{{identifier}}' + scope: entity.name.function.java + pop: 1 + + method-expect-parameters: + - meta_content_scope: meta.function.identifier.java + - include: method-parameters + - match: (?=\{) + pop: 1 + - include: member-else-fail + + method-maybe-parameters: + - meta_content_scope: meta.function.identifier.java + - include: method-parameters + - include: else-pop + + method-parameters: + - match: \( + scope: punctuation.section.group.begin.java + set: + - method-parameters-body + - receiver-or-parameter + + method-parameters-body: + - meta_scope: meta.function.parameters.java meta.group.java + - include: group-end + - match: ',' + scope: punctuation.separator.comma.java + push: + - parameter-maybe-identifier + - parameter-maybe-variadic + - maybe-array-modifiers + - parameter-type + - include: expression-terminator + + method-array-modifiers: + - meta_include_prototype: false + - match: '' + set: method-array-modifiers-content + + method-array-modifiers-content: + - meta_scope: meta.function.java + - include: maybe-array-modifiers + + method-attributes: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4.6 + - match: throws{{break}} + scope: keyword.declaration.throws.java + set: + - method-throws-body + - maybe-illegal-array-modifiers + - expect-object-type + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-9.html#jls-9.6.2 + - match: default{{break}} + scope: keyword.declaration.default.java + set: method-default-body + - include: else-pop + + method-default-body: + - meta_scope: meta.function.default.java + - include: variable-initializer + + method-throws-body: + - meta_scope: meta.function.throws.java + - match: ',' + scope: punctuation.separator.comma.java + push: + - maybe-illegal-array-modifiers + - expect-object-type + - include: else-pop + + method-block: + - match: \{ + scope: punctuation.section.block.begin.java + set: method-block-body + - include: else-pop + + method-block-body: + - meta_scope: meta.function.java meta.block.java + - include: block-body + +###[ VARIABLE DECLARATIONS ]################################################### + + variable-declaration-type: + - include: primitive-type + - include: var-type + - include: object-type + - include: final-modifiers + - include: annotations + - include: illegal-storage-modifiers + - include: else-pop + + variable-declaration-type-modifier: + - clear_scopes: 1 + - meta_scope: meta.declaration.type.java + - include: maybe-only-array-modifiers + + variable-declaration-list: + - match: ',' + scope: + meta.declaration.java + punctuation.separator.comma.java + push: + - variable-declaration-value-assignment + - variable-declaration-maybe-identifier + - include: else-pop + + variable-declaration-expect-identifier: + - include: variable-declaration-identifier + - include: declaration-else-fail + + variable-declaration-maybe-identifier: + - include: variable-declaration-identifier + - include: else-pop + + variable-declaration-identifier: + - match: '{{uppercase_id}}' + scope: constant.other.java + pop: 1 + - match: '{{identifier}}' + scope: variable.other.java + pop: 1 + + variable-declaration-value-assignment: + - meta_content_scope: meta.declaration.identifier.java + - match: = + scope: + meta.declaration.java + keyword.operator.assignment.java + set: variable-declaration-value-initializer + # found parentheses after identifier, appears to be a method declaration + - match: (?=\() + fail: declarations + - include: maybe-only-array-modifiers + + variable-declaration-value-initializer: + - meta_content_scope: meta.declaration.value.java + - include: variable-initializer + +###[ VARIABLE DECLARATIONS OR ASSIGNMENTS ]#################################### + + variable-declarations-or-assignments: + # A subset of `declarations` to optimize performance in contexts which need + # to distinguish between variable declaration and variable assignment only. + - match: (?=[{{id_first_char}}@<]) + branch_point: variable-declarations-or-assignments + branch: + - variable-maybe-declaration + - variable-maybe-assignment + + variable-maybe-assignment: + - meta_include_prototype: false + - match: '' + set: + - variable-maybe-modifier + - variable-expect-identifier + + variable-maybe-modifier: + - meta_content_scope: meta.variable.identifier.java + - include: maybe-only-array-modifiers + + variable-maybe-declaration: + - meta_include_prototype: false + - match: '' + set: + - variable-declaration-list + - variable-declaration-value-assignment + - variable-expect-identifier + - variable-declaration-type-modifier + - variable-declaration-type + + variable-expect-identifier: + - include: variable-declaration-identifier + - match: (?=\S) + fail: variable-declarations-or-assignments + +###[ IF ELSE STATEMENTS ]###################################################### + + if-else-statements: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.9 + - match: if{{break}} + scope: keyword.control.conditional.if.java + push: + - if-meta + - block-or-expression + - maybe-group + - match: else{{break}} + scope: keyword.control.conditional.else.java + push: + - else-meta + - block-or-expression + + if-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.conditional.if.java + - include: immediately-pop + + else-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.conditional.else.java + - include: immediately-pop + +###[ SWITCH CASE STATEMENTS ]################################################## + + switch-case-statements: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.11 + - match: case{{break}} + scope: keyword.control.conditional.case.java + branch_point: case-label + branch: + - case-label-constant + - case-label-expression + - match: default{{break}} + scope: keyword.control.conditional.default.java + push: case-default-end + - match: switch{{break}} + scope: keyword.control.conditional.switch.java + push: + - switch-meta + - block-or-expression + - maybe-group + + switch-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.conditional.switch.java + - include: immediately-pop + + case-default-end: + - meta_scope: meta.statement.conditional.default.java + - match: ':|->' + scope: punctuation.separator.expressions.java + pop: 1 + - include: else-pop + + case-label-constant: + - meta_scope: meta.statement.conditional.case.java + - match: (?=\S) + set: + - case-label-constant-end + - case-label-constant-identifier + + case-label-constant-identifier: + - include: literal-constant + - include: constant + - include: annotations + - include: case-label-fail + + case-label-constant-end: + - meta_content_scope: meta.statement.conditional.case.label.java + - include: case-label-end + - match: (?=[;{}]|(?:{{keywords}}|{{storage_types}}|{{storage_modifiers}}){{break}}) + pop: 1 + - include: case-label-fail + + case-label-expression: + - meta_scope: meta.statement.conditional.case.java + - match: (?=\S) + set: case-label-expression-body + + case-label-expression-body: + - meta_content_scope: meta.statement.conditional.case.label.java + - include: case-label-end + - include: expression + + case-label-end: + - match: ':|->' + scope: meta.statement.conditional.case.java punctuation.separator.expressions.java + pop: 1 + + case-label-fail: + - match: (?=\S) + fail: case-label + +###[ DO WHILE STATEMENTS ]##################################################### + + do-while-statements: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.12 + - match: while{{break}} + scope: keyword.control.loop.while.java + push: + - while-meta + - block-or-expression + - maybe-group + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.13 + - match: do{{break}} + scope: keyword.control.loop.do-while.java + push: + - do-meta + - block-or-expression + + do-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.loop.do-while.java + - include: immediately-pop + + while-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.loop.while.java + - include: immediately-pop + +###[ FOR LOOP STATEMENTS ]##################################################### + + for-statements: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.14 + - match: for{{break}} + scope: keyword.control.loop.for.java + push: + - for-meta + - block-or-expression + - for-parameters + + for-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.loop.for.java + - include: immediately-pop + + for-parameters: + - match: \( + scope: punctuation.section.group.begin.java + set: + - for-parameters-update + - for-parameters-init + - include: else-pop + + for-parameters-init: + # enhanced for statement + - match: ':' + scope: keyword.operator.assignment.java + pop: 1 + # basic for statement + - match: ';' + scope: punctuation.terminator.java + set: for-parameters-condition + - include: variable-declarations-or-assignments + - include: expressions + - include: expression-terminator + + for-parameters-condition: + - include: punctuation-terminator-semicolon-pop + - include: expressions + - include: expression-terminator + + for-parameters-update: + - meta_scope: meta.group.java + - include: group-end + - include: expressions + - match: ; + scope: invalid.illegal.stray.java + - include: expression-terminator + +###[ FLOW CONTROL STATEMENTS ]################################################# + + labeled-statements: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.7 + - match: ({{identifier}})(:)(?!:) + captures: + 1: entity.name.label.java + 2: punctuation.separator.colon.java + + flow-control-statements: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.10 + - match: assert{{break}} + scope: keyword.control.flow.assert.java + push: assert-statement-body + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.15 + - match: break{{break}} + scope: keyword.control.flow.break.java + push: + - break-statement-end + - variable-label + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.16 + - match: continue{{break}} + scope: keyword.control.flow.continue.java + push: + - continue-statement-end + - variable-label + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.17 + - match: return{{break}} + scope: keyword.control.flow.return.java + push: return-statement-body + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.18 + - match: throw{{break}} + scope: keyword.control.flow.throw.java + push: throw-statement-body + # https://docs.oracle.com/javase/specs/jls/se16/html/jls-14.html#jls-14.21 + - match: yield{{break}} + scope: keyword.control.flow.yield.java + push: yield-statement-body + + assert-statement-body: + - meta_scope: meta.statement.conditional.assertion.java + - match: ':' + scope: punctuation.separator.expressions.java + - include: expression + + break-statement-end: + - meta_scope: meta.statement.flow.break.java + - include: expect-expression-terminator + + continue-statement-end: + - meta_scope: meta.statement.flow.continue.java + - include: expect-expression-terminator + + return-statement-body: + - meta_scope: meta.statement.flow.return.java + - include: expression + + throw-statement-body: + - meta_scope: meta.statement.flow.throw.java + - include: expression + + yield-statement-body: + - meta_scope: meta.statement.flow.yield.java + - include: expression + + variable-label: + - match: '{{identifier}}' + scope: variable.label.java + pop: 1 + - include: else-pop + +###[ SYNCHRONIZED STATEMENTS ]################################################# + + synchronized-statements: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.19 + - match: synchronized{{break}} + scope: keyword.control.flow.synchronized.java + push: + - synchronized-meta + - block-or-expression + - maybe-group + + synchronized-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.flow.synchronized.java + - include: immediately-pop + +###[ TRY CATCH STATEMENTS ]#################################################### + + try-catch-statements: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.20 + - match: catch{{break}} + scope: keyword.control.exception.catch.java + push: + - catch-meta + - block-or-expression + - catch-parameters + - match: finally{{break}} + scope: keyword.control.exception.finally.java + push: + - finally-meta + - block-or-expression + - match: try{{break}} + scope: keyword.control.exception.try.java + push: + - try-meta + - block-or-expression + - try-parameters + + catch-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.exception.catch.java + - include: immediately-pop + + catch-parameters: + - match: \( + scope: punctuation.section.group.begin.java + set: + - catch-parameters-end + - maybe-illegal-array-modifiers + - catch-parameter-identifier + - maybe-illegal-array-modifiers + - catch-parameter-type + - include: else-pop + + catch-parameter-type: + - include: final-modifiers + - include: illegal-storage-modifiers + - include: expect-object-type + + catch-parameter-identifier: + - match: \| + scope: punctuation.separator.pipe.java + push: + - maybe-illegal-array-modifiers + - catch-parameter-type + - match: '{{identifier}}' + scope: variable.other.java + pop: 1 + - match: '{{variables}}{{break}}' + scope: invalid.illegal.identifier.java + pop: 1 + - include: else-pop + + catch-parameters-end: + - meta_scope: meta.group.java + - include: group-end + - match: '[^\s\)]+' + scope: invalid.illegal.unexpected-token.java + + finally-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.exception.finally.java + - include: immediately-pop + + try-meta: + - meta_include_prototype: false + - meta_scope: meta.statement.exception.try.java + - include: immediately-pop + + try-parameters: + - match: \( + scope: punctuation.section.group.begin.java + set: try-parameters-body + - include: else-pop + + try-parameters-body: + - meta_scope: meta.group.java + - include: group-end + - include: variable-declarations-or-assignments + - include: punctuation-terminator-semicolon + - include: expressions + - include: expression-terminator + +###[ EXPRESSIONS ]############################################################# + + else-expressions: + - match: (?=\S) + push: expression + + else-expression: + - match: (?=\S) + set: expression + + expression: + - include: expression-terminator + - include: expressions + + expression-terminator: + - match: |- + (?x)(?= + [;)\]{}] | + ( {{control_keywords}} + | {{declaration_keywords}} + | {{storage_modifiers}} + | {{storage_types}} + ){{break}} + ) + pop: 1 + + expect-expression-terminator: + - include: expression-terminator + - match: \S + scope: invalid.illegal.expect-terminator.java + +###[ INSTANTIATION EXPRESSIONS ]############################################### + + instantiations: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.9 + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.10 + - match: new{{break}} + scope: keyword.other.storage.new.java + push: + - instantiation-meta + - instantiation-arguments + - instantiation-type + - maybe-type-argument + - include: annotations + + instantiation-meta: + - meta_include_prototype: false + - meta_scope: meta.instantiation.java + - include: immediately-pop + + instantiation-type: + - include: primitive-type + - include: object-type + - include: annotations + - include: illegal-storage-modifiers + - include: illegal-unexpected-keywords + - include: else-pop + + instantiation-arguments: + - match: \( + scope: punctuation.section.group.begin.java + set: + - class-block + - group-body + - include: array-dimensions + - include: else-pop + + array-dimensions: + - match: \[ + scope: punctuation.section.brackets.begin.java + set: array-dimension-body + - include: array-initializer + - include: annotations + + array-dimension-body: + - meta_scope: meta.brackets.java + - match: \] + scope: punctuation.section.brackets.end.java + set: + - include: array-dimensions + - include: else-pop + - include: expressions + - include: expression-terminator + +###[ INITIALIZATION EXPRESSIONS ]############################################## + + variable-initializers: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.3 + - include: array-initializers + - include: ternary-initializers + - include: expressions + + variable-initializer: + - match: (?=,) + pop: 1 + - include: array-initializers + - include: ternary-initializers + - include: expression + + array-initializers: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-10.html#jls-10.6 + - match: \{ + scope: punctuation.section.braces.begin.java + push: array-initializer-body + + array-initializer: + - match: \{ + scope: punctuation.section.braces.begin.java + set: array-initializer-body + + array-initializer-body: + - meta_scope: meta.braces.java + - match: \} + scope: punctuation.section.braces.end.java + pop: 1 + - include: variable-initializers + + ternary-initializers: + - match: \? + scope: keyword.operator.ternary.java + push: ternary-initializer-body + + ternary-initializer-body: + - include: operator-ternary-colon + - include: variable-initializer + +###[ BLOCKS ]################################################################## + + block-or-expression: + - include: block + - include: else-expression + + blocks: + - match: \{ + scope: punctuation.section.block.begin.java + push: block-body + - include: stray-braces + + block: + - match: \{ + scope: punctuation.section.block.begin.java + set: block-body + + block-end: + - match: \} + scope: punctuation.section.block.end.java + pop: 1 + + block-body: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.2 + - meta_scope: meta.block.java + - include: block-end + - include: statements + - include: declarations + - include: else-expressions + +###[ GROUPS ]################################################################## + + groups: + - match: \( + scope: punctuation.section.group.begin.java + branch_point: groups + branch: + - cast-expression-group + - expression-group + - lambda-parameter-group + + group-else-fail: + - match: (?=\S) + fail: groups + + maybe-group: + - match: \( + scope: punctuation.section.group.begin.java + set: group-body + - include: else-pop + + group-body: + - meta_scope: meta.group.java + - include: group-end + - include: expressions + - include: expression-terminator + + group-end: + - match: \) + scope: punctuation.section.group.end.java + pop: 1 + +###[ CAST EXPRESSION GROUPS ]################################################## + + cast-expression-group: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.16 + - meta_scope: meta.cast.java meta.group.java + - meta_include_prototype: false + - match: '' + set: + - cast-expression-group-body + - maybe-only-array-modifiers + - cast-expression-type + + cast-expression-group-body: + - meta_scope: meta.cast.java meta.group.java + - match: \) + scope: punctuation.section.group.end.java + set: cast-expression-group-end + - include: additional-bounds + - include: group-else-fail + + cast-expression-group-end: + # cast expressions may be followed by: + # - `!` : unary operator + # - `~` : unary operator + # - `(` : cast, lambda or group expression + # - literal : variable, type or method + - match: (?=[{{id_first_char}}!~(]) + pop: 1 + - include: group-else-fail + + cast-expression-type: + - include: primitive-type + - include: object-type + - include: illegal-var-type + - include: annotations + - include: maybe-type-argument + +###[ EXPRESSION GROUPS ]####################################################### + + expression-group: + - meta_scope: meta.group.java + - match: \) + scope: punctuation.section.group.end.java + set: expression-group-end + - include: expressions + - include: expression-terminator + + expression-group-end: + # looks like a lambda + - match: (?=->) + fail: groups + - include: else-pop + +###[ LAMBDA PARAMETER GROUPS ]################################################# + + lambda-parameter-group: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.27 + - meta_scope: meta.function.anonymous.parameters.java meta.group.java + - match: \) + scope: punctuation.section.group.end.java + set: lambda-meta + - match: (?=[{{id_first_char}}@<]) + branch_point: lambda-parameter-declaration + branch: + - lambda-parameter-declaration + - lambda-parameter-declaration-identifier + - include: punctuation-separator-comma + - include: expect-expression-terminator + + lambda-parameter-declaration: + - meta_include_prototype: false + - match: '' + set: + - lambda-parameter-declaration-identifier + - parameter-maybe-variadic + - maybe-array-modifiers + - variable-declaration-type + + lambda-parameter-declaration-identifier: + - include: parameter-identifier + - match: (?=\S) + fail: lambda-parameter-declaration + + lambdas: + - match: -> + scope: + meta.function.anonymous.java + keyword.declaration.function.arrow.java + push: + - lambda-meta + - block-or-expression + + lambda-meta: + - meta_content_scope: meta.function.anonymous.java + - include: else-pop + +###[ RECEIVER OR FORMAL PARAMETERS ]########################################### + + receiver-or-parameter: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4 + # The first parameter of a method or constructor declaration may be a + # receiver parameter which represents the object to invoke the method for. + - match: (?=[{{id_first_char}}<]) + branch_point: receiver-or-parameter + branch: + - receiver + - parameter + - include: annotation-else-pop + + receiver: + - meta_include_prototype: false + - match: '' + pop: 1 + set: + - receiver-identifier + - receiver-type + + receiver-type: + # A 'receiver-type' is basically an 'object-type' whose 'namespace' part + # is skipped as it is expected to be declared in the same source file due + # to receiver args being valid only for nested class' methods. + - match: (?={{reserved_words}}{{break}}) + fail: receiver-or-parameter + - match: (?=\S) + branch_point: receiver-type + branch: + - receiver-unqualified-type + - receiver-qualified-type + + receiver-unqualified-type: + - match: '{{identifier}}' + scope: storage.type.class.java + push: + - receiver-unqualified-type-end + - maybe-array-modifiers + - maybe-type-argument + - include: else-pop2 + + receiver-unqualified-type-end: + - match: (?={{id_first_char}}) + pop: 3 + - match: (?={{single_dot}}) + fail: receiver-type + - match: (?=\S) + fail: receiver-or-parameter + + receiver-qualified-type: + - meta_scope: meta.path.java + - match: '{{identifier}}' + scope: storage.type.class.java + push: + - receiver-qualified-type-end + - qualified-object-type-arguments + - include: annotation-else-pop2 + + receiver-qualified-type-end: + - match: \s*({{single_dot}}) + captures: + 1: punctuation.accessor.dot.java + pop: 1 + # consume comments + - match: \s*(?=/[/*]) + # Maintain meta.path boundaries at the end of the type. + - match: (?=\s*\S) + pop: 3 + + receiver-identifier: + - match: (?=\S) + branch_point: receiver-identifier + branch: + - receiver-unqualified-identifier + - receiver-qualified-identifier + + receiver-unqualified-identifier: + - match: this{{break}} + scope: variable.parameter.this.java + push: receiver-identifier-end + - match: '{{identifier}}' + scope: variable.parameter.java + set: receiver-unqualified-identifier-end + - include: annotation-else-pop2 + + receiver-unqualified-identifier-end: + - match: (?={{single_dot}}) + fail: receiver-identifier + - match: (?=\S) + fail: receiver-or-parameter + + receiver-qualified-identifier: + - meta_include_prototype: false + - match: '' + branch_point: receiver-qualified-identifier + branch: + - receiver-qualified-identifier-path + - receiver-qualified-identifier-name + + receiver-qualified-identifier-path: + - meta_scope: meta.path.java + - match: '{{id}}' + scope: storage.type.class.java + push: + - receiver-qualified-identifier-accessor + - maybe-type-argument + - include: annotation-else-pop3 + + receiver-qualified-identifier-accessor: + - include: punctuation-accessor-dot-pop2 + - match: (?=\S) + fail: receiver-qualified-identifier + + receiver-qualified-identifier-name: + - meta_scope: meta.path.java + - match: this{{break}} + scope: variable.parameter.this.java + set: receiver-identifier-end + - match: '{{identifier}}' + scope: invalid.illegal.identifier.java + set: receiver-identifier-end + - include: annotation-else-pop3 + + receiver-identifier-end: + - include: illegal-array-modifiers + - include: illegal-members + - include: annotation-else-pop3 + + parameter: + - meta_include_prototype: false + - match: '' + pop: 1 + set: + - parameter-maybe-identifier + - parameter-maybe-variadic + - maybe-array-modifiers + - parameter-type + + parameter-type: + - include: final-modifiers + - include: illegal-storage-modifiers + - include: primitive-type + - include: illegal-var-type + - include: maybe-object-type + + parameter-maybe-variadic: + - match: \.\.\. + scope: keyword.operator.variadic.java + pop: 1 + - include: annotation-else-pop + + parameter-maybe-identifier: + - include: parameter-identifier + - include: else-pop + + parameter-identifier: + - match: '{{identifier}}' + scope: variable.parameter.java + set: maybe-only-array-modifiers + - match: '{{variables}}{{break}}' + scope: invalid.illegal.identifier.java + set: maybe-only-array-modifiers + +###[ VARIABLES ]############################################################### + + variables: + # Note: + # 1) `variable-other` must be the first branch to scope the very last + # identifier before eof or end of embedded section as ordinary variable. + # 2) `variable-qualifier` scopes identifiers not followed by ClassCaseIds + # as ordinary variables. Found no easy enough solution by only using + # `variable-other` and `variable-namespace`. + - match: (?={{id_first_char}}) + branch_point: variables + branch: + - variable-other + - variable-namespace + - variable-qualifier + - method-call-identifier + - lambda-parameter + - include: variable-item-access + + method-call-identifier: + - meta_include_prototype: false + - match: '{{id}}' + scope: + meta.function-call.identifier.java + variable.function.java + set: method-call-arguments + - include: immediately-pop + + method-call-arguments: + - meta_content_scope: meta.function-call.identifier.java + - match: \( + scope: punctuation.section.group.begin.java + set: method-call-arguments-body + - match: (?=\S) + fail: variables + + method-call-arguments-body: + - meta_scope: meta.function-call.arguments.java meta.group.java + - include: group-body + + lambda-parameter: + - meta_include_prototype: false + - match: '{{id}}' + scope: + meta.function.anonymous.parameters.java + variable.parameter.java + set: lambda-parameter-end + - include: immediately-pop + + lambda-parameter-end: + - meta_content_scope: meta.function.anonymous.java + - include: else-pop + + variable-namespace: + - match: '{{lowercase_id}}' + scope: variable.namespace.java + push: variable-namespace-accessor + - match: '' + fail: variables + + variable-namespace-accessor: + - meta_scope: meta.path.java + - match: '{{single_dot}}' + scope: punctuation.accessor.dot.java + set: + - match: '{{classcase_id}}' + scope: storage.type.class.java + set: + - variable-namespace-meta + - maybe-object-type-child + - maybe-array-modifiers + - maybe-type-argument + - include: else-pop + - match: (?=\S) + fail: variables + + variable-namespace-meta: + - meta_include_prototype: false + - meta_scope: meta.path.java + - include: immediately-pop2 + + variable-other: + - meta_include_prototype: false + - match: '{{id}}' + scope: + meta.variable.identifier.java + variable.other.java + set: variable-other-end + - include: immediately-pop + + variable-other-end: + - meta_content_scope: meta.variable.identifier.java + - match: \s*(\.|\(|->) + fail: variables + - include: variable-item-access-end + + variable-qualifier: + - meta_include_prototype: false + - match: '{{id}}' + scope: + meta.variable.identifier.java + variable.other.java + set: variable-qualifier-end + - include: immediately-pop + + variable-qualifier-end: + - meta_content_scope: meta.variable.identifier.java + - match: \s*(\(|->) + fail: variables + - include: variable-item-access-end + + variable-item-access: + - match: \[ + scope: punctuation.section.brackets.begin.java + push: variable-item-access-body + + variable-item-access-body: + - meta_scope: meta.variable.item-access.java meta.brackets.java + - match: \] + scope: punctuation.section.brackets.end.java + set: variable-item-access-end + - include: expressions + - include: expression-terminator + + variable-item-access-end: + - meta_content_scope: meta.variable.item-access.java + - match: \s*(?=\[|/[/*]) + - match: (?=\s*\S) + pop: 1 + + variable-language-class: + - match: class{{break}} + scope: variable.language.class.java + pop: 1 + + maybe-function-reference: + - match: new{{break}} + scope: keyword.other.storage.new.java + pop: 1 + - match: '{{identifier}}' + scope: variable.function.reference.java + pop: 1 + - include: else-pop + +###[ LITERALS ]################################################################ + + literals: + - include: literal-chars + - include: literal-strings + - include: literal-numbers + - include: literal-constants + - include: literal-variables + + literal-variables: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.9 + - match: _{{break}} + scope: variable.language.anonymous.java + - match: super{{break}} + scope: variable.language.super.java + - match: this{{break}} + scope: variable.language.this.java + + literal-constants: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.10.3 + - match: (?:false|true){{break}} + scope: constant.language.boolean.java + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.10.7 + - match: null{{break}} + scope: constant.language.null.java + + literal-constant: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.10.3 + - match: (?:false|true){{break}} + scope: constant.language.boolean.java + pop: 1 + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.10.7 + - match: null{{break}} + scope: constant.language.null.java + pop: 1 + + literal-numbers: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.10 + # hexadecimal floats + - match: |- + (?x) + # 0x1., 0x1.1, 0x1.1p1, 0x1.1p-1, 0x1.p1, 0x1.p-1 | 0x1p1 | 0x.1, 0x.1p1, 0x.1p-1 + (0[xX]) ( {{hex_digit}}* (?: ({{single_dot}}) {{hex_digit}}* (?:{{hex_exponent}})? | {{hex_exponent}} ) ) ({{float_suffix}})? + scope: meta.number.float.hexadecimal.java + captures: + 1: constant.numeric.base.java + 2: constant.numeric.value.java + 3: punctuation.separator.decimal.java + 4: constant.numeric.suffix.java + # decimal floats + - match: |- + (?x) + ([0-9]{{dec_digit}}*) + (?: + # 1., 1.1, 1.1e1, 1.1e-1, 1.e1, 1.e-1, 1.d, 1.1d, 1.1e1d, 1.1e-1d, 1.e1d, 1.e-1d + ( ({{single_dot}}) {{dec_digit}}* (?:{{dec_exponent}})? ) ({{float_suffix}})? + # 1e1 1e1d + | ({{dec_exponent}}) ({{float_suffix}})? + # 1d + | ({{float_suffix}}) + ) + | ( ({{single_dot}}) {{dec_digit}}+ (?:{{dec_exponent}})? ) ({{float_suffix}})? + scope: meta.number.float.decimal.java + captures: + 1: constant.numeric.value.java + 2: constant.numeric.value.java + 3: punctuation.separator.decimal.java + 4: constant.numeric.suffix.java + 5: constant.numeric.value.java + 6: constant.numeric.suffix.java + 7: constant.numeric.suffix.java + 8: constant.numeric.value.java + 9: punctuation.separator.decimal.java + 10: constant.numeric.suffix.java + # binary integers + - match: (0[bB])({{bin_digit}}*)({{int_suffix}})? + scope: meta.number.integer.binary.java + captures: + 1: constant.numeric.base.java + 2: constant.numeric.value.java + 3: constant.numeric.suffix.java + # hexadecimal integers + - match: (0[xX])({{hex_digit}}*)({{int_suffix}})? + scope: meta.number.integer.hexadecimal.java + captures: + 1: constant.numeric.base.java + 2: constant.numeric.value.java 3: constant.numeric.suffix.java # octal integers - - match: \b(0)({{oct_digit}}+)([lL]\b|(?![\d_])) + - match: (0)({{oct_digit}}+)({{int_suffix}}|(?![\d_])) scope: meta.number.integer.octal.java captures: 1: constant.numeric.base.java 2: constant.numeric.value.java 3: constant.numeric.suffix.java # decimal integers - - match: \b((0_*)?[1-9]{{dec_digit}}*|0(?![\d_]))([lL]\b)? + - match: ((0_*)?[1-9]{{dec_digit}}*|0(?![\d_]))({{int_suffix}})? scope: meta.number.integer.decimal.java captures: 1: constant.numeric.value.java 2: invalid.illegal.numeric.java 3: constant.numeric.suffix.java - keywords: - - match: '::' - scope: punctuation.accessor.double-colon.java - push: - - match: '{{id}}' - scope: variable.function.reference.java - pop: true - - include: any_POP - - match: '\?|:' - scope: keyword.operator.ternary.java - - match: \binstanceof\b - scope: keyword.operator.word.instanceof.java - - match: (<<|>>>?) - scope: keyword.operator.bitshift.java - - match: (==|!=|<=|>=|<>|<|>) + literal-chars: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.10.4 + - match: (')(?:({{escape_unicode}})|({{escape_octal}})|({{escape_other}})|([^']))(') + scope: meta.string.java string.quoted.single.java + captures: + 1: punctuation.definition.string.begin.java + 2: constant.character.escape.unicode.java + 3: constant.character.escape.octal.java + 4: constant.character.escape.other.java + 5: constant.character.literal.java + 6: punctuation.definition.string.end.java + + literal-strings: + - include: literal-double-quoted-textblocks + - include: literal-double-quoted-strings + - include: literal-single-quoted-strings + + literal-single-quoted-strings: + # Java doesn't support single quoted strings, but Groovy does. + - match: (')[^']+(') + scope: invalid.illegal.not-a-char.java + + literal-double-quoted-strings: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.10.5 + - match: \" + scope: punctuation.definition.string.begin.java + push: literal-double-quoted-string-body + + literal-double-quoted-string-body: + - meta_include_prototype: false + - meta_scope: meta.string.java string.quoted.double.java + - match: \" + scope: punctuation.definition.string.end.java + pop: 1 + - include: illegal-newline + - include: literal-string-escapes + + literal-double-quoted-textblocks: + # https://docs.oracle.com/javase/specs/jls/se16/html/jls-3.html#jls-3.10.6 + - match: (\"{3})\s*(.*)$ + captures: + 1: punctuation.definition.string.begin.java + 2: invalid.illegal.unexpected-content.java + push: literal-double-quoted-textblock-body + + literal-double-quoted-textblock-body: + - meta_include_prototype: false + - meta_scope: meta.string.java string.quoted.triple.java + - match: \"{3} + scope: punctuation.definition.string.end.java + pop: 1 + - include: literal-string-escapes + + literal-string-escapes: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.3 + - match: '{{escape_unicode}}' + scope: constant.character.escape.unicode.java + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.10.6 + - match: '{{escape_octal}}' + scope: constant.character.escape.octal.java + - match: '{{escape_other}}' + scope: constant.character.escape.other.java + - match: \\. + scope: invalid.illegal.escape.java + +###[ OPERATORS ]############################################################### + + operators: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-3.html#jls-3.12 + - match: (<<|>>>?|[-+*/%|&\^])= + scope: keyword.operator.assignment.augmented.java + - match: '<<|>>>?' + scope: keyword.operator.bitwise.java + - match: '==|!=|<=|>=|<>|<|>' scope: keyword.operator.comparison.java - - match: (\-\-|\+\+) - scope: keyword.operator.increment-decrement.java - - match: (\-|\+|\*|\/|%) + - match: '=' + scope: keyword.operator.assignment.java + push: variable-initializer + - match: '\+\+?|\-\-?|[*/%]' scope: keyword.operator.arithmetic.java - - match: (!|&&|\|\|) + - match: '!|&&|\|\|' scope: keyword.operator.logical.java - - match: (~|\^|&|\|) + - match: '[~|&\^]' scope: keyword.operator.bitwise.java - - match: (\.)(class\b)? - captures: - 1: punctuation.accessor.dot.java - 2: variable.language.java - - include: punctuation-separator-comma - - include: punctuation-terminator-semicolon + - match: '\?' + scope: keyword.operator.ternary.java + push: ternary-expression + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.20.2 + - match: instanceof{{break}} + scope: keyword.other.storage.instanceof.java + push: + - maybe-only-array-modifiers + - cast-expression-type - keywords-control: - # exceptions - - match: \bcatch\b - scope: keyword.control.exception.catch.java + operator-ternary-colon: + - match: ':' + scope: keyword.operator.ternary.java + pop: 1 + + ternary-expression: + - include: operator-ternary-colon + - include: expression + +###[ PUNCTUATIONS ]############################################################ + + punctuations: + - match: '::' + scope: punctuation.accessor.double-colon.java push: - - meta_scope: meta.catch.java - - match: (?=\() - set: - - match: \( - scope: punctuation.section.parens.begin.java - set: - - meta_scope: meta.catch.parameters.java meta.parens.java - - match: \) - scope: punctuation.section.parens.end.java - pop: true - - match: \| - scope: punctuation.separator.bar.java - - include: parameters - - include: any_POP - - match: \bfinally\b - scope: keyword.control.exception.finally.java - - match: \btry\b - scope: keyword.control.exception.try.java - push: declaration-statement-parens - # flow - - match: \bassert\b - scope: keyword.control.flow.assert.java + - maybe-function-reference + - maybe-type-argument + - match: '{{single_dot}}' + scope: punctuation.accessor.dot.java push: - - meta_scope: meta.assertion.java - - match: (?=;) - pop: true - - match: ':' - scope: punctuation.separator.expressions.java - - include: code - - match: \bbreak\b - scope: keyword.control.flow.break.java - - match: \bcontinue\b - scope: keyword.control.flow.continue.java - - match: \breturn\b - scope: keyword.control.flow.return.java - - match: \bthrow\b - scope: keyword.control.flow.throw.java - # conditional - - match: \bif\b - scope: keyword.control.conditional.if.java - - match: \belse\b - scope: keyword.control.conditional.else.java - - match: \bswitch\b - scope: keyword.control.conditional.switch.java - - match: \bcase\b - scope: keyword.control.conditional.case.java - - match: \bdefault\b - scope: keyword.control.conditional.default.java - # loop - - match: \bdo\b - scope: keyword.control.loop.do-while.java - - match: \bfor\b - scope: keyword.control.loop.for.java - push: declaration-statement-parens - - match: \bwhile\b - scope: keyword.control.loop.while.java + - include: variable-language-class + - include: maybe-type-argument + - include: punctuation-separator-comma + + punctuation-accessor-dot: + - match: '{{single_dot}}' + scope: punctuation.accessor.dot.java + + punctuation-accessor-dot-pop: + - match: '{{single_dot}}' + scope: punctuation.accessor.dot.java + pop: 1 + + punctuation-accessor-dot-pop2: + - match: '{{single_dot}}' + scope: punctuation.accessor.dot.java + pop: 2 + + punctuation-separator-comma: + - match: ',' + scope: punctuation.separator.comma.java + + punctuation-terminator-semicolon: + - match: ; + scope: punctuation.terminator.java + + punctuation-terminator-semicolon-pop: + - match: ; + scope: punctuation.terminator.java + pop: 1 + +###[ CONSTANT ]################################################################ + + constant: + - match: (?={{identifier}}) + branch_point: constant + branch: + - unqualified-constant + - qualified-constant + + unqualified-constant: + - meta_include_prototype: false + - match: '{{id}}' + scope: constant.other.java + set: unqualified-constant-end + - include: immediately-pop2 + + unqualified-constant-end: + - match: (?={{single_dot}}) + fail: constant + - include: else-pop2 + + qualified-constant: + - meta_include_prototype: false + - meta_content_scope: meta.path.java + - match: '' + branch_point: qualified-constant + branch: + - qualified-constant-package + - qualified-constant-class-or-name + + qualified-constant-package: + - match: '{{lowercase_id}}' + scope: variable.namespace.java + set: qualified-constant-package-accessor + - include: annotations + - match: (?=\S) + fail: qualified-constant + + qualified-constant-package-accessor: + - include: punctuation-accessor-dot-pop + - match: (?=\S) + fail: qualified-constant - illegal-keywords: - - match: \b(goto|const)\b - scope: invalid.illegal.keyword.java + qualified-constant-class-or-name: + - meta_include_prototype: false + - match: '' + pop: 1 + branch_point: qualified-constant-class-or-name + branch: + - qualified-constant-class + - qualified-constant-name + + qualified-constant-class: + - meta_include_prototype: false + - match: '{{identifier}}' + scope: storage.type.class.java + set: + - qualified-constant-class-accessor + - maybe-type-argument + - include: annotation-else-pop3 - illegal-open-block: - - match: \s?(?={) - scope: invalid.illegal.stray-terminator-end - pop: true + qualified-constant-class-accessor: + - include: punctuation-accessor-dot-pop + - match: (?=\S) + fail: qualified-constant-class-or-name - illegal-semicolon: - - match: ; - scope: invalid.illegal.stray-terminator-end - pop: true + qualified-constant-name: + - meta_include_prototype: false + - match: '{{identifier}}' + scope: constant.other.java + pop: 3 + - include: annotation-else-pop3 - illegal-parens-terminators: - # Pops the stack if anything matches - - include: illegal-semicolon - - include: illegal-open-block +###[ ENTITY CLASS ]############################################################ - method-invocations: - - match: (\.)\s*(?=<) - captures: - 1: punctuation.accessor.dot.java - push: generic-type-invocation - - match: ({{id}})\s*(\() - captures: - 1: variable.function.java - 2: punctuation.section.parens.begin.java - push: - - meta_scope: meta.function-call.java - - match: \) - scope: punctuation.section.parens.end.java - pop: true - - include: illegal-parens-terminators - - include: code - - fields-and-methods: - - match: \bvoid\b - scope: storage.type.void.java - push: method - - match: (?={{id}}\s*\() - push: method - - match: '{{before_fqn}}' - push: [field-or-method, after-object-and-array-types, object-type-fqn] - - match: \b{{classcase_id}} - scope: support.class.java - push: [field-or-method, after-object-and-array-types] - - match: \b{{primitives}}\b - scope: storage.type.primitive.java - push: [field-or-method, array-brackets] + entity-class: + - match: (?={{identifier}}) + branch_point: entity-class + branch: + - entity-class-qualified-identifier + - entity-class-unqualified-identifier - field-or-method: - - match: (?={{id}}\s*\() - set: method - - match: (?=\S) + entity-class-qualified-identifier: + - match: '{{id}}' + scope: variable.namespace.java set: - - include: before-next-field - - match: (?:({{uppercase_id}})|({{id}})) - captures: - 1: entity.name.constant.java - 2: meta.field.java - push: [static-assignment, array-brackets] - - include: punctuation-separator-comma - - include: any_POP - - before-next-field: - # Prevent style from being removed from whole file when making a new expression - - match: (?=\b(?:{{storage_modifiers}}|{{primitives}}|void)\b) - pop: true - - method: - - meta_scope: meta.method.java - - match: ({{classcase_id}})\s*(?=\() - captures: - 1: meta.method.identifier.java entity.name.function.constructor.java - - match: ({{id}})\s*(?=\() - captures: - 1: meta.method.identifier.java entity.name.function.java - - match: \( - scope: punctuation.section.parens.begin.java - push: - - meta_scope: meta.method.parameters.java meta.parens.java - - match: \) - scope: punctuation.section.parens.end.java - pop: true - - include: parameters - - match: \S - scope: invalid.illegal.missing-parameter-end - pop: true - - include: throws - - include: annotation-default - - match: \{ - scope: punctuation.section.block.begin.java + - meta_scope: meta.path.java + - match: '{{single_dot}}' + scope: punctuation.accessor.dot.java + set: + - meta_include_prototype: false + - meta_content_scope: meta.path.java + - match: '' + branch_point: entity-class-path + branch: + - entity-class-qualifier + - entity-class-identifier + - match: (?=\S) + fail: entity-class + + entity-class-qualifier: + - match: '{{identifier}}' + scope: variable.namespace.java set: - - meta_scope: meta.method.java meta.method.body.java - - match: \} - scope: punctuation.section.block.end.java - pop: true - - include: code-block - - include: any_POP - - throws: - - match: \bthrows\b - scope: keyword.declaration.throws.java - push: - - - meta_scope: meta.method.throws.java - - match: \, - scope: punctuation.separator.comma.java - push: object-type-reference - - include: any_POP - - object-type-reference - - # Stand-along uppercase id, either type or constant. - # Should be used only inside code blocks. - uppercase-identifiers: - # Popular JDK classes - - match: \b(?:UUID|UR[LI])\b - scope: support.class.java - push: after-object-type - # Generic type variable - - match: \b\p{Lu}\b - scope: support.class.java - push: after-object-type - # Uppercase constants - - match: \b{{uppercase_id}} - scope: constant.other.java + - entity-class-accessor + - maybe-type-argument + - include: else-pop2 - # Stand-alone type, maybe type of the variable or class object reference. - # Should be used only inside code blocks. - object-types: - # Here the match is more complex than 'before_fqn'. - # In code block we can't simply distinguish package from variable. - - match: (?=\b(?:{{lowercase_id}}\.)+\p{Lu}) - push: [after-object-type, object-type-fqn] - - match: \b{{classcase_id}}\b - scope: support.class.java - push: after-object-type - - object-type-fqn: - - meta_scope: meta.path.java - - include: package - - match: '{{classcase_id}}' - scope: support.class.java - pop: true - - include: any_POP - - after-object-type: - - match: (?=<) - set: [array-brackets, generic-type-invocation] - - match: \.(?!\.) - scope: punctuation.accessor.dot.java + entity-class-accessor: + - include: punctuation-accessor-dot-pop + - match: (?=\S) + fail: entity-class-path + + entity-class-identifier: + - match: '{{identifier}}' + scope: entity.name.class.java set: - - match: (?=<) - set: generic-type-invocation - - match: (?:(class)\b|({{uppercase_id}})) - captures: - 1: variable.language.java - 2: constant.other.java - pop: true - - match: '{{classcase_id}}' - scope: support.class.java - set: after-object-type - - include: any_POP - - include: array-brackets - - # Used in 'throws' and generic bounds - object-type-reference: - - match: '{{before_fqn}}' + - immediately-pop2 + - maybe-type-argument + - include: else-pop2 + + entity-class-unqualified-identifier: + - match: '{{id}}' + scope: entity.name.class.java + set: maybe-type-argument + +###[ ENTITY MODULE ]########################################################### + + entity-module: + - match: (?={{identifier}}) + branch_point: entity-module + branch: + - entity-module-qualified-identifier + - entity-module-unqualified-identifier + + entity-module-qualified-identifier: + - match: '{{id}}' + scope: variable.namespace.java set: - meta_scope: meta.path.java - - include: package - - include: object-type-reference-no-fqn - - include: object-type-reference-no-fqn + - match: '{{single_dot}}' + scope: punctuation.accessor.dot.java + set: + - meta_include_prototype: false + - meta_content_scope: meta.path.java + - match: '' + branch_point: entity-module-path + branch: + - entity-module-qualifier + - entity-module-identifier + - match: (?=\S) + fail: entity-module + + entity-module-qualifier: + - match: '{{identifier}}' + scope: variable.namespace.java + set: entity-module-accessor + - include: else-pop2 + + entity-module-accessor: + - include: punctuation-accessor-dot-pop + - match: (?=\S) + fail: entity-module-path - object-type-reference-no-fqn: - - match: '{{classcase_id}}' - scope: support.class.java - set: after-object-type-reference - - include: any_POP - - after-object-type-reference: - - match: (?=<) - set: generic-type-invocation - - match: \. - scope: punctuation.accessor.dot.java - set: object-type-reference-no-fqn - - include: any_POP + entity-module-identifier: + - match: '{{identifier}}' + scope: entity.name.namespace.module.java + pop: 2 + - include: else-pop2 - # Used in method's and generic's parameters - object-and-array-types: - - match: '{{before_fqn}}' - push: + entity-module-unqualified-identifier: + - match: '{{id}}' + scope: entity.name.namespace.module.java + pop: 1 + +###[ ENTITY PACKAGE ]########################################################## + + entity-package: + - match: (?={{identifier}}) + branch_point: entity-package + branch: + - entity-package-qualified-identifier + - entity-package-unqualified-identifier + + entity-package-qualified-identifier: + - match: '{{id}}' + scope: variable.namespace.java + set: - meta_scope: meta.path.java - - include: package - - include: object-and-array-types-no-fqn - - match: \b({{primitives}})(?=\s*\[) - scope: storage.type.primitive.java - push: array-brackets - - match: \b{{classcase_id}} - scope: support.class.java - push: after-object-and-array-types + - match: '{{single_dot}}' + scope: punctuation.accessor.dot.java + set: + - meta_include_prototype: false + - meta_content_scope: meta.path.java + - match: '' + branch_point: entity-package-path + branch: + - entity-package-qualifier + - entity-package-identifier + - match: (?=\S) + fail: entity-package + + entity-package-qualifier: + - match: '{{identifier}}' + scope: variable.namespace.java + set: entity-package-accessor + - include: else-pop2 + + entity-package-accessor: + - include: punctuation-accessor-dot-pop + - match: (?=\S) + fail: entity-package-path + + entity-package-identifier: + - match: '{{identifier}}' + scope: entity.name.namespace.package.java + pop: 2 + - include: else-pop2 + + entity-package-unqualified-identifier: + - match: '{{id}}' + scope: entity.name.namespace.package.java + pop: 1 - object-and-array-types-no-fqn: +###[ OBJECT TYPES ]############################################################ + + object-types: + # Popular JDK classes, generic type variable + - match: (?:UUID|UR[LI]|\p{Lu}){{break}} + scope: storage.type.class.java + push: + - maybe-object-type-child + - maybe-array-modifiers + - maybe-type-argument + # Uppercase constants + - match: '{{uppercase_id}}' + scope: constant.other.java + # Classes - match: '{{classcase_id}}' - scope: support.class.java - set: after-object-and-array-types - - include: any_POP - - after-object-and-array-types: - - match: (?=<) - set: [array-brackets, generic-type-invocation] - - match: \.(?!\.) + scope: storage.type.class.java + push: + - maybe-object-type-child + - maybe-array-modifiers + - maybe-type-argument + + maybe-object-type-child: + - match: '{{single_dot}}' scope: punctuation.accessor.dot.java - set: object-and-array-types-no-fqn - - include: array-brackets + set: object-types-child-identifier + - include: else-pop - # Used in class-level 'extends' and 'implements' - inherited-object-type-reference: - - match: '{{before_fqn}}' + object-types-child-identifier: + - include: variable-language-class + - match: '{{uppercase_id}}' + scope: constant.other.java + pop: 1 + - match: '{{classcase_id}}' + scope: storage.type.class.java set: - - meta_scope: meta.path.java - - match: '{{lowercase_id}}' - scope: entity.other.inherited-class.package.java - - include: punctuation-accessor-dot - - include: inherited-object-type-reference-no-fqn - - include: inherited-object-type-reference-no-fqn - - inherited-object-type-reference-no-fqn: - - match: (?!class|extends|implements|interface){{id}} - scope: entity.other.inherited-class.java - set: after-inherited-object-type-reference - - include: any_POP + - maybe-object-type-child + - maybe-array-modifiers + - maybe-type-argument + - include: annotation-else-pop - after-inherited-object-type-reference: - - match: (?=<) - set: generic-type-invocation - - match: \. - scope: punctuation.accessor.dot.java - set: inherited-object-type-reference-no-fqn - - include: any_POP +###[ OBJECT TYPE ]############################################################# - generic-type-declaration: - - match: < - scope: punctuation.definition.generic.begin.java - push: generic-type-parameter - - include: any_POP - - generic-type-terminator: - - include: illegal-semicolon - # These characters can't appear in a generic. If we've matched - # them then someone forgot to close it. - - match: (?=[{}()]) - pop: true - - match: '>' - scope: punctuation.definition.generic.end.java - pop: true + expect-object-type: + - include: object-type + - include: annotations + - include: illegal-unexpected-reserved + - include: else-pop + + maybe-object-type: + - include: object-type + - include: annotation-else-pop + + object-type: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-4.html#jls-4.3 + - match: (?={{identifier}}) + branch_point: object-type + branch: + - unqualified-object-type + - qualified-object-type + + unqualified-object-type: + - match: '{{id}}' + scope: storage.type.class.java + push: + - unqualiefied-object-type-end + - maybe-type-argument - generic-type-parameter: - - meta_scope: meta.generic.declaration.java - - match: \b{{id}}\b - scope: variable.parameter.type.java - push: generic-type-bounds - - include: generic-type-terminator + unqualiefied-object-type-end: + - match: (?={{single_dot}}) + fail: object-type + - include: else-pop3 + + qualified-object-type: + - meta_include_prototype: false + - meta_scope: meta.path.java + - match: '' + branch_point: qualified-object-type + branch: + - qualified-object-type-package + - qualified-object-type-class + + qualified-object-type-package: + - match: '{{lowercase_id}}' + scope: variable.namespace.java + set: qualified-object-type-accessor + - include: annotations + - match: (?=\S) + fail: qualified-object-type + + qualified-object-type-accessor: + - include: punctuation-accessor-dot-pop + - match: (?=\S) + fail: qualified-object-type - generic-type-bounds: - - match: (,)|(?=>) + qualified-object-type-class: + - match: '{{identifier}}' + scope: storage.type.class.java + push: + - qualified-object-type-end + - qualified-object-type-arguments + - include: annotation-else-pop3 + + qualified-object-type-arguments: + - match: (?=\s*<) + set: maybe-type-argument + - match: (?=\s*\S) + pop: 1 + + qualified-object-type-end: + - match: \s*({{single_dot}}) captures: - 1: punctuation.separator.comma.java - pop: true - - match: \bextends\b - scope: keyword.declaration.extends.java - push: [generic-type-extends-multiple-bounds, object-type-reference] - - match: \bsuper\b - scope: keyword.declaration.super.java - push: object-type-reference + 1: punctuation.accessor.dot.java + pop: 1 + - match: (?=\s*\S) + pop: 4 + +###[ REFERENCE TYPE ]########################################################## + + maybe-additional-bounds: + - include: additional-bounds + - include: else-pop - generic-type-extends-multiple-bounds: + additional-bounds: - match: '&' - scope: keyword.operator.multiple-bounds.java - set: [generic-type-extends-multiple-bounds, object-type-reference] - - include: any_POP + scope: keyword.operator.logical.java + push: maybe-reference-type + + maybe-reference-type: + - include: reference-type + - include: annotation-else-pop + + reference-type: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-4.html#jls-4.3 + - match: (?={{storage_types}}{{break}}) + branch_point: primitive-array-type + branch: + - reference-type-array + - reference-type-illegal + - match: (?={{id_first_char}}) + set: + - maybe-array-modifiers + - maybe-object-type - generic-type-invocation: - - match: < - scope: punctuation.definition.generic.begin.java - set: generic-type-argument - - include: any_POP + reference-type-array: + # note: simplified pattern as primitive types consist of ascii chars only + - match: '[A-Za-z]+' + scope: storage.type.primitive.java + set: reference-type-array-item-access - generic-type-argument: - - meta_scope: meta.generic.java - - match: \? - scope: keyword.operator.wildcard.java - push: generic-type-bounds - - include: generic-type-terminator - - include: object-and-array-types + reference-type-array-item-access: + - match: (?=\[) + pop: 1 + set: maybe-array-modifiers - include: annotations - - include: punctuation-separator-comma + - match: (?=\S) + fail: primitive-array-type - annotation-default: - - match: \bdefault\b - scope: keyword.declaration.default.java + reference-type-illegal: + # note: simplified pattern as primitive types consist of ascii chars only + - match: '[A-Za-z]+' + scope: invalid.illegal.unexpected-keyword.java + pop: 2 + +###[ INHERRITED TYPE REFERENCES ]############################################## + + # Used in class-level 'extends' and 'implements' + inherited-object-type-list: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.1.4 + - match: ',' + scope: punctuation.separator.comma.java + push: inherited-object-type + + inherited-object-type: + - match: (?={{identifier}}) + branch_point: inherited-object-type + branch: + - unqualified-inherited-object-type + - qualified-inherited-object-type + - include: annotation-else-pop + + unqualified-inherited-object-type: + - match: '{{id}}' + scope: entity.other.inherited-class.java push: - - meta_scope: meta.annotation.default.java - - match: (?=;) - pop: true - - include: code + - unqualiefied-inherited-object-type-end + - maybe-type-argument - parameters: - - match: \bfinal\b - scope: storage.modifier.java + unqualiefied-inherited-object-type-end: + - match: (?={{single_dot}}) + fail: inherited-object-type + - include: illegal-array-modifiers + - include: annotation-else-pop3 + + qualified-inherited-object-type: + - meta_include_prototype: false + - meta_scope: meta.path.java + - match: '' + branch_point: qualified-inherited-object-type + branch: + - qualified-inherited-object-type-package + - qualified-inherited-object-type-class + + qualified-inherited-object-type-package: + - match: '{{lowercase_id}}' + scope: variable.namespace.java + set: qualified-inherited-object-type-accessor - include: annotations - - include: primitive-types - - include: object-and-array-types - - match: \.\.\. - scope: keyword.operator.variadic.java - - match: '{{id}}' - scope: variable.parameter.java - push: array-brackets - - include: punctuation-separator-comma + - match: (?=\S) + fail: qualified-inherited-object-type - lambdas: - - match: (?={{lambda_lookahead}}) - push: lambda-params + qualified-inherited-object-type-accessor: + - include: punctuation-accessor-dot-pop + - match: (?=\S) + fail: qualified-inherited-object-type - lambda-params: - - meta_scope: meta.function.anonymous.parameters.java - - match: \( - scope: punctuation.section.parens.begin.java + qualified-inherited-object-type-class: + - match: '{{identifier}}' + scope: entity.other.inherited-class.java + push: + - qualified-object-type-end + - qualified-object-type-arguments + - include: annotation-else-pop3 + +###[ TYPE ARGUMENTS ]########################################################## + + maybe-type-argument: + - include: type-argument + - include: else-pop + + type-argument: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-4.html#jls-4.5.1 + - match: <> + scope: + meta.generic.java + punctuation.section.generic.diamond.java + pop: 1 + - match: < + scope: punctuation.section.generic.begin.java set: - - meta_scope: meta.function.anonymous.parameters.java - - match: \) - scope: punctuation.section.parens.end.java - set: lambda-arrow - - include: parameters - - match: '{{id}}' - scope: variable.parameter.java - set: lambda-arrow + - type-argument-body + - type-argument-reference - lambda-arrow: - - match: -> - scope: storage.type.function.anonymous.java + type-argument-body: + - meta_scope: meta.generic.java + - match: ',' + scope: punctuation.separator.comma.java + push: type-argument-reference + - include: type-parameter-end + + type-argument-reference: + - match: \? + scope: variable.language.wildcard.java + set: type-argument-bounds + - include: maybe-reference-type + + type-argument-bounds: + - match: extends{{break}} + scope: storage.modifier.extends.java set: - - meta_scope: meta.function.anonymous.body.java - - match: (?=[)};]) - pop: true - - include: code + - maybe-additional-bounds + - maybe-reference-type + - match: super{{break}} + scope: keyword.declaration.super.java + set: maybe-reference-type + - include: else-pop - parens: - - match: \( - scope: punctuation.section.parens.begin.java +###[ TYPE PARAMETERS ]######################################################### + + maybe-type-parameter: + - include: type-parameter + - include: else-pop + + type-parameters: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.1.2 + - match: < + scope: punctuation.section.generic.begin.java push: - - meta_scope: meta.parens.java - - match: \) - scope: punctuation.section.parens.end.java - pop: true - - include: illegal-parens-terminators - - include: code - - declaration-statement-parens: - - match: \( - scope: punctuation.section.parens.begin.java + - type-parameter-body + - type-parameter-bounds + - type-parameter-reference + + type-parameter: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.1.2 + - match: < + scope: punctuation.section.generic.begin.java + set: + - type-parameter-body + - type-parameter-bounds + - type-parameter-reference + + type-parameter-body: + - meta_scope: meta.generic.declaration.java + - match: ',' + scope: punctuation.separator.comma.java + push: + - type-parameter-bounds + - type-parameter-reference + - include: type-parameter-end + + type-parameter-reference: + # https://docs.oracle.com/javase/specs/jls/se13/html/jls-4.html#jls-4.4 + - match: '{{identifier}}' + scope: variable.parameter.type.java + pop: 1 + - match: \?|{{storage_types}}{{break}} + scope: invalid.illegal.unexpected-keyword.java + pop: 1 + - include: annotation-else-pop + + type-parameter-bounds: + - match: extends{{break}} + scope: storage.modifier.extends.java set: - - meta_scope: meta.parens.java - - match: \) - scope: punctuation.section.parens.end.java - pop: true - - include: illegal-open-block - - include: code-block - - include: any_POP + - maybe-additional-bounds + - maybe-reference-type + - match: super{{break}} + scope: invalid.illegal.unexpected-keyword.java + set: maybe-reference-type + - include: else-pop + + type-parameter-end: + - match: '>' + scope: punctuation.section.generic.end.java + pop: 1 + - match: extends{{break}} + scope: invalid.illegal.unexpected-keyword.java + push: + - maybe-additional-bounds + - maybe-reference-type + - match: super{{break}} + scope: invalid.illegal.unexpected-keyword.java + push: maybe-reference-type + - include: annotation-else-pop + +###[ PRIMITIVE TYPES ]######################################################### primitive-types: - - match: \b{{primitives}}\b + - match: '{{storage_types}}{{break}}' + scope: storage.type.primitive.java + push: maybe-array-modifiers + + primitive-type: + - match: '{{storage_types}}{{break}}' scope: storage.type.primitive.java - push: array-brackets + pop: 1 + + var-types: + - match: var{{break}} + scope: storage.type.variant.java + push: maybe-illegal-array-modifiers var-type: - - match: \bvar\b - scope: storage.type.var.java + - match: var{{break}} + scope: storage.type.variant.java + set: maybe-illegal-array-modifiers + + maybe-array-modifiers: + - include: array-modifiers + - include: annotation-else-pop + + maybe-only-array-modifiers: + - include: array-modifiers + - include: annotations + - include: illegal-members + - include: else-pop - array-brackets: + array-modifiers: - match: \[\s*\] scope: storage.modifier.array.java - - include: any_POP - static-assignment: - - match: \= - scope: keyword.operator.assignment.java - set: - - meta_scope: meta.assignment.rhs.java - - match: (?=[,;]) - pop: true - - include: before-next-field - - include: code - - include: stray-parens - - include: any_POP - - assignment: - - match: ([|&^*/+-]\=|\=(?!=)) - scope: keyword.operator.assignment.java - push: - - meta_scope: meta.assignment.rhs.java - - match: (?=;|\)|\}|,) - pop: true - - include: code - static-code-block: - - match: \{ - scope: punctuation.section.block.begin.java - push: - - meta_scope: meta.static.body.java - - match: \} - scope: punctuation.section.block.end.java - pop: true - - include: code-block + final-modifiers: + - match: final{{break}} + scope: storage.modifier.java + storage-modifiers: - - match: \b{{storage_modifiers}}\b + - match: '{{storage_modifiers}}{{break}}' scope: storage.modifier.java - stray-braces: - - match: \} - scope: invalid.illegal.stray-brace-end - stray-parens: - - match: \) - scope: invalid.illegal.stray-parens-end - strings: - - match: \" - scope: punctuation.definition.string.begin.java - push: - - meta_include_prototype: false - - meta_scope: string.quoted.double.java - - match: \" - scope: punctuation.definition.string.end.java - pop: true - - include: strings-common - - match: \' - scope: punctuation.definition.string.begin.java - push: - - meta_include_prototype: false - - meta_scope: string.quoted.single.java - - match: \' - scope: punctuation.definition.string.end.java - pop: true - - include: strings-common - - strings-common: - - match: \n - scope: invalid.illegal.newline.java - pop: true - - include: string-escapes +###[ PROTOTYPES ]############################################################## - string-escapes: - - match: \\u+\h{4} - scope: constant.character.escape.unicode.java - - match: \\[0-3]?[0-7]{1,2} - scope: constant.character.escape.octal.java - - match: \\[btnfr"'\\] - scope: constant.character.escape.java - - match: \\. - scope: invalid.illegal.escape.java + prototype: + - include: comments + - include: illegal-keywords - module: - - match: (?=\b(?:open\s+)?module\b) - push: - - - meta_scope: meta.module.java - - include: immediate_POP - - - match: \bopen\b - scope: storage.modifier.java - - match: \bmodule\b - scope: storage.type.java - set: [module-body, module-identifier-scope, module-identifier] - - module-identifier-scope: - - meta_scope: meta.module.identifier.java - - include: immediate_POP + annotation-else-pop: + - include: annotations + - include: else-pop - module-identifier: - - match: '{{id}}' - set: - - - meta_scope: entity.name.module.java - - include: immediate_POP - - dot-separated-identifier - - include: any_POP + annotation-else-pop2: + - include: annotations + - include: else-pop2 - module-body: - - match: \{ - scope: punctuation.section.braces.begin.java - set: - - meta_scope: meta.module.body.java - - include: module-body-content - - match: \} - scope: punctuation.section.braces.end.java - pop: true - - include: any_POP - - module-body-content: - - match: \bexports\b - scope: keyword.other.module.exports.java - push: [exports-statement-scope, exports-or-opens-statement] - - match: \bopens\b - scope: keyword.other.module.opens.java - push: [opens-statement-scope, exports-or-opens-statement] - - match: \brequires\b - scope: keyword.other.module.requires.java - push: requires-statement - - match: \buses\b - scope: keyword.other.module.uses.java - push: [uses-statement-scope, object-type-reference] - - match: \bprovides\b - scope: keyword.other.module.provides.java - push: [provides-statement-scope, provides-with-statement, object-type-reference] - - include: punctuation-terminator-semicolon + annotation-else-pop3: + - include: annotations + - include: else-pop3 - # Should always come before module/package patterns - module-statement-terminator: - - match: (?=[;\}]) - pop: true - - match: (?=\b(?:requires|exports|uses|provides|opens)\b) - pop: true + else-pop: + - match: (?=\S) + pop: 1 - support-type-module: - - match: '{{id}}' - push: - - - meta_scope: support.type.module.java - - include: immediate_POP - - dot-separated-identifier + else-pop2: + - match: (?=\S) + pop: 2 - exports-statement-scope: - - meta_scope: meta.exports.java - - include: immediate_POP + else-pop3: + - match: (?=\S) + pop: 3 - opens-statement-scope: - - meta_scope: meta.opens.java - - include: immediate_POP + immediately-pop: + - match: '' + pop: 1 - exports-or-opens-statement: - - match: \bto\b - scope: keyword.other.module.to.java - set: - - include: module-statement-terminator - - include: support-type-module - - include: punctuation-separator-comma - - include: module-statement-terminator - - match: '{{id}}' + immediately-pop2: + - match: '' + pop: 2 + + immediately-pop3: + - match: '' + pop: 3 + +###[ ILLEGALS ]################################################################ + + maybe-illegal-array-modifiers: + - include: illegal-array-modifiers + - include: annotation-else-pop + + illegal-array-modifiers: + - match: \[\s*\] + scope: invalid.illegal.unexpected-modifier.java + + illegal-keywords: + - match: '{{illegal_keywords}}{{break}}' + scope: invalid.illegal.keyword.java + + illegal-unexpected-keywords: + - match: '{{keywords}}{{break}}' + scope: invalid.illegal.unexpected-keyword.java + + illegal-unexpected-reserved: + - match: '{{reserved_words}}' + scope: invalid.illegal.unexpected-keyword.java + pop: 1 + + illegal-members: + - match: '{{single_dot}}' + scope: invalid.illegal.unexpected-accessor.java push: - - - meta_scope: support.type.package.java - - include: immediate_POP - - dot-separated-identifier + - maybe-illegal-array-modifiers + - maybe-illegal-member - requires-statement: - - meta_scope: meta.requires.java - - match: \btransitive\b - scope: keyword.other.module.transitive.java - - include: module-statement-terminator - - include: support-type-module + maybe-illegal-member: + - match: '{{id}}' + scope: invalid.illegal.unexpected-member.java + pop: 1 + - include: else-pop - uses-statement-scope: - - meta_scope: meta.uses.java - - include: immediate_POP + illegal-newline: + - match: \n + scope: invalid.illegal.unexpected-newline.java + pop: 1 - provides-statement-scope: - - meta_scope: meta.provides.java - - include: immediate_POP + illegal-storage-modifiers: + - match: '{{storage_modifiers}}{{break}}' + scope: invalid.illegal.unexpected-keyword.java - provides-with-statement: - - match: \bwith\b - scope: keyword.other.module.with.java - set: - - - match: \, - scope: punctuation.separator.comma.java - push: object-type-reference - - include: any_POP - - object-type-reference - - include: any_POP + maybe-illegal-type-parameter: + - match: \< + set: illegal-type-parameter-body + - include: else-pop + + illegal-type-parameter-body: + - meta_scope: invalid.illegal.unexpected-type-parameters.java + - match: \< + push: + - match: \> + pop: 1 + - match: \> + pop: 1 + + illegal-var-type: + - match: var{{break}} + scope: invalid.illegal.unexpected-keyword.java + pop: 1 + + stray-braces: + - match: \} + scope: invalid.illegal.stray.java + + stray-group: + - match: \) + scope: invalid.illegal.stray.java diff --git a/Java/JavaDoc.sublime-syntax b/Java/JavaDoc.sublime-syntax index 422a6a9833..8cf041754d 100644 --- a/Java/JavaDoc.sublime-syntax +++ b/Java/JavaDoc.sublime-syntax @@ -1,195 +1,286 @@ %YAML 1.2 --- -# http://www.sublimetext.com/docs/3/syntax.html -name: Javadoc -file_extensions: [] +############################################################################### +# Notes: +# +# The comment block is part of Java Syntax and thus scoped +# `comment.block.documentation.java`. +# +# The comment's content followed by the first `*` of each line contains the +# JavaDoc content itself. +# +# JavaDoc is pure HTML with some specific JavaDoc Tags being supported for +# easier authoring. A JavaDoc may contain: +# +# - HTML tags : content : meta.tag.html +# - JavaDoc Inline Tags : {@tag content} : meta.tag.inline.javadoc +# - JavaDoc Block Tags : @tag content : meta.tag.block.javadoc +# +# While `HTML Tags` and `JavaDoc Inline Tags` are supported everywhere, +# `JavaDoc Block Tags` form the block tag section following the description +# section. Each tag terminates a former block tag's content (if one) and +# starts a new block section. Only the first token after `*` is matched as +# `JavaDoc Block Tag`. +# +# References: +# +# https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#documentation +# https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#documentationcomments +# http://www.sublimetext.com/docs/syntax.html +# +############################################################################### + +name: JavaDoc scope: text.html.javadoc +version: 2 hidden: true +extends: Packages/HTML/HTML (Plain).sublime-syntax + +############################################################################### + variables: id: '(?:[\p{L}_$][\p{L}\p{N}_$]*)' - javadoc_block_tag_terminator: (?=^\s*\*?\s*@) + +############################################################################### contexts: - prototype: - # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#leadingasterisks - - match: ^\s*(\*)\s*(?!\s*@) - captures: - 1: punctuation.definition.comment.javadoc + # The main context can be included directly by a 3rd-party syntax. + # + # Example: + # + # - include: scope:text.html.javadoc + # main: - - meta_include_prototype: false - - match: /\*\* - scope: comment.block.documentation.javadoc punctuation.definition.comment.begin.javadoc - embed: contents - embed_scope: comment.block.documentation.javadoc text.html.javadoc - escape: \*/ + - match: /\*\*+ + scope: + comment.block.documentation.java + punctuation.definition.comment.begin.java + embed: javadoc + embed_scope: comment.block.documentation.java + escape: \*+/ escape_captures: - 0: comment.block.documentation.javadoc punctuation.definition.comment.end.javadoc + 0: comment.block.documentation.java + punctuation.definition.comment.end.java - contents: - - meta_include_prototype: false + # The javadoc context can be used to embed JavaDoc content. + # + # Example: + # + # - match: /\*\*+ + # scope: + # comment.block.documentation.java + # punctuation.definition.comment.begin.java + # embed: scope:text.html.javadoc#javadoc + # embed_scope: comment.block.documentation.java + # escape: \*+/ + # escape_captures: + # 0: comment.block.documentation.java + # punctuation.definition.comment.end.java + # + javadoc: + - match: '' + set: [javadoc-body, javadoc-block-tag] - # Block tag in the first line (immediately after '/**'). - - match: \s*(?=@) - embed: javadoc-block-tags - escape: '{{javadoc_block_tag_terminator}}' + javadoc-body: + - match: ^\s*(\*)?\s* + captures: + 1: punctuation.definition.comment.java + push: javadoc-block-tag + - include: javadoc-inline-formatting - # We rely on 'escape' to pop the inner context out. - # 'set' unfortunately will mess up the meta scopes. - - match: '' - push: - - match: ^\s*(\*)?\s*(?=@) - captures: - 1: punctuation.definition.comment.javadoc - embed: javadoc-block-tags - escape: '{{javadoc_block_tag_terminator}}' - - include: inline-formatting - - inline-formatting: - - include: javadoc-inline-tags - - include: scope:text.html.basic + javadoc-asterisk: + - match: ^(?:\s*(\*)\s?)? + captures: + 1: punctuation.definition.comment.java + pop: 1 - javadoc-block-tag-base: - - meta_scope: meta.block-tag.javadoc - - include: inline-formatting +###[ JAVADOC BLOCK TAGS ]###################################################### - javadoc-block-tags: + javadoc-block-tag: # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#param - - match: (@)param\b - scope: keyword.other.documentation.param.javadoc - captures: - 1: punctuation.definition.keyword.javadoc - push: [javadoc-block-tag-base, param-tag-parameter] + - match: \@param\b + scope: meta.tag.block.javadoc entity.name.tag.documentation.javadoc + set: + - javadoc-block-tag-common + - javadoc-block-tag-param-args # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#see - - match: (@)see\b - scope: keyword.other.documentation.see.javadoc - captures: - 1: punctuation.definition.keyword.javadoc - push: [javadoc-block-tag-base, see-tag-content] + - match: \@see\b + scope: meta.tag.block.javadoc entity.name.tag.documentation.javadoc + set: + - javadoc-block-tag-common + - javadoc-block-tag-reference # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#throws - - match: (@)(throws|exception)\b - scope: keyword.other.documentation.throws.javadoc - captures: - 1: punctuation.definition.keyword.javadoc - push: [javadoc-block-tag-base, reference] - - match: (@)(uses|provides)\b - scope: keyword.other.documentation.uses-or-provides.javadoc - captures: - 1: punctuation.definition.keyword.javadoc - push: [javadoc-block-tag-base, reference] - - match: (@)(return|deprecated|author|version|since|apiNote|impl(?:Note|Spec)|moduleGraph|serial(?:Field|Data)?)\b - scope: keyword.other.documentation.javadoc - captures: - 1: punctuation.definition.keyword.javadoc - push: javadoc-block-tag-base - - match: '@' - pop: true + - match: \@(throws|exception)\b + scope: meta.tag.block.javadoc entity.name.tag.documentation.javadoc + set: + - javadoc-block-tag-common + - javadoc-block-tag-reference + - match: \@(uses|provides)\b + scope: meta.tag.block.javadoc entity.name.tag.documentation.javadoc + set: + - javadoc-block-tag-common + - javadoc-block-tag-reference + - match: \@(return|deprecated|author|version|since|apiNote|impl(?:Note|Spec)|moduleGraph|serial(?:Field|Data)?)\b + scope: meta.tag.block.javadoc entity.name.tag.documentation.javadoc + set: javadoc-block-tag-common + - match: (?=\S)|$ + pop: 1 + + javadoc-block-tag-common: + - include: javadoc-block-tag-terminator + - include: javadoc-inline-formatting - param-tag-parameter: + javadoc-block-tag-param-args: + - include: javadoc-block-tag-terminator - match: \S+ scope: variable.parameter.javadoc - pop: true + pop: 1 - see-tag-content: - - match: (?=['<]) - pop: true - - match: (?=\S) - set: reference + javadoc-block-tag-reference: + - include: javadoc-block-tag-terminator + - include: javadoc-reference - reference: - - match: (?:{{id}}\.)*{{id}}(?:#{{id}})?|#{{id}} - scope: markup.underline.link.javadoc - set: - - match: \( - scope: markup.underline.link.javadoc - set: - - match: \) - scope: markup.underline.link.javadoc - pop: true - - match: . - scope: markup.underline.link.javadoc - - match: '' - pop: true - - javadoc-inline-tag-terminator: - - match: \} - scope: punctuation.section.inline-tag.end.javadoc - pop: true + javadoc-block-tag-terminator: + - match: (?=^\s*\*?\s*@) + pop: 1 + - match: ^\s*(\*)\s* + captures: + 1: punctuation.definition.comment.java - javadoc-inline-tag-base: - - meta_scope: meta.inline-tag.javadoc - - include: javadoc-inline-tag-terminator +###[ JAVADOC INLINE TAGS ]##################################################### + + javadoc-inline-formatting: + - include: javadoc-inline-tags + - include: javadoc-html-tags - # Multi-line tags mustn't highlight leading asterisk. javadoc-inline-tags: # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#code # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#literal - - match: ({)((@)(?:code|literal))(?:\s+|(?=\})) + - match: ({)(@(?:code|literal))(?:\s+|(?=\})) captures: - 1: punctuation.section.inline-tag.begin.javadoc - 2: keyword.other.documentation.code-or-literal.javadoc - 3: punctuation.definition.keyword.javadoc - push: - - meta_scope: meta.inline-tag.javadoc - - include: javadoc-inline-tag-terminator - - include: code-tag-bracket-balancing - - match: ^\s+ - - match: . - scope: markup.raw.javadoc + 1: punctuation.definition.tag.begin.javadoc + 2: entity.name.tag.documentation.javadoc + push: javadoc-inline-tag-raw # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#link - - match: ({)((@)link(?:plain)?)\b + - match: ({)(@link(?:plain)?)\b captures: - 1: punctuation.section.inline-tag.begin.javadoc - 2: keyword.other.documentation.link.javadoc - 3: punctuation.definition.keyword.javadoc - push: [javadoc-inline-tag-base, link-tag-label, reference-in-inline-tag] + 1: punctuation.definition.tag.begin.javadoc + 2: entity.name.tag.documentation.javadoc + push: + - javadoc-inline-tag-common + - javadoc-inline-tag-label + - javadoc-inline-tag-reference # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#value - - match: ({)((@)value)\b + - match: ({)(@value)\b captures: - 1: punctuation.section.inline-tag.begin.javadoc - 2: keyword.other.documentation.value.javadoc - 3: punctuation.definition.keyword.javadoc - push: [javadoc-inline-tag-base, reference-in-inline-tag] + 1: punctuation.definition.tag.begin.javadoc + 2: entity.name.tag.documentation.javadoc + push: + - javadoc-inline-tag-common + - javadoc-inline-tag-reference # http://openjdk.java.net/jeps/225 # https://bugs.openjdk.java.net/browse/JDK-8178725 - - match: ({)((@)(?:index|extLink))\b + - match: ({)(@(?:index|extLink))\b captures: - 1: punctuation.section.inline-tag.begin.javadoc - 2: keyword.other.documentation.javadoc - 3: punctuation.definition.keyword.javadoc - push: javadoc-inline-tag-base + 1: punctuation.definition.tag.begin.javadoc + 2: entity.name.tag.documentation.javadoc + push: javadoc-inline-tag-common # https://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#inheritDoc - - match: ({)((@)inheritDoc)(}) - scope: meta.inline-tag.javadoc + - match: ({)(@inheritDoc)(}) + scope: meta.tag.inline.javadoc captures: - 1: punctuation.section.inline-tag.begin.javadoc - 2: keyword.other.documentation.javadoc - 3: punctuation.definition.keyword.javadoc - 4: punctuation.section.inline-tag.end.javadoc + 1: punctuation.definition.tag.begin.javadoc + 2: entity.name.tag.documentation.javadoc + 3: punctuation.definition.tag.end.javadoc + + javadoc-inline-tag-end: + - match: \} + scope: punctuation.definition.tag.end.javadoc + pop: 1 + + javadoc-inline-tag-common: + - meta_scope: meta.tag.inline.javadoc + - include: javadoc-inline-tag-end + - include: javadoc-inline-tag-continuation-1 + + javadoc-inline-tag-continuation-1: + # Leading asterisk (*) characters on each line are discarded; + # Blanks preceding the initial asterisk (*) characters are also discarded. + - match: $ + push: + - clear_scopes: 1 # clear `meta.tag.inline` + - include: javadoc-inline-tag-continuation-body + + javadoc-inline-tag-continuation-2: + # Leading asterisk (*) characters on each line are discarded; + # Blanks preceding the initial asterisk (*) characters are also discarded. + - match: $ + push: + - clear_scopes: 2 # clear `meta.tag.inline markup.[raw|reference]` + - include: javadoc-inline-tag-continuation-body + + javadoc-inline-tag-continuation-body: + - match: (?=\}) + pop: 1 + - include: javadoc-asterisk + + javadoc-inline-tag-raw: + - meta_scope: meta.tag.inline.javadoc + - meta_content_scope: markup.raw.javadoc + - include: javadoc-inline-tag-end + - include: javadoc-inline-tag-raw-braces - code-tag-bracket-balancing: + javadoc-inline-tag-raw-braces: - match: \{ - scope: markup.raw.javadoc push: - match: \} - scope: markup.raw.javadoc - pop: true - - include: code-tag-bracket-balancing - - match: . - scope: markup.raw.javadoc + pop: 1 + - include: javadoc-inline-tag-raw-braces + - include: javadoc-inline-tag-continuation-2 - link-tag-label: + javadoc-inline-tag-label: - match: \s* set: - meta_content_scope: meta.label.javadoc - - include: scope:text.html.basic - match: (?=\}) - pop: true + pop: 1 + - include: javadoc-inline-tag-continuation-2 + - include: javadoc-html-tags - reference-in-inline-tag: - - match: '' - set: reference - with_prototype: - - match: (?=\}) - pop: true + javadoc-inline-tag-reference: + - include: javadoc-inline-tag-continuation-1 + - include: javadoc-reference + + javadoc-reference: + # url + - match: \w+://\S+ + scope: markup.underline.link.javadoc + # class reference + - match: (?:{{id}}\.)*{{id}}(?:#{{id}})?|#{{id}} + scope: markup.underline.link.javadoc + set: + - match: \( + set: + - meta_scope: markup.underline.link.javadoc + - match: \) + pop: 1 + - include: javadoc-inline-tag-continuation-2 + - include: immediately-pop + - include: else-pop + +###[ JAVADOC HTML TAGS ]####################################################### + + javadoc-html-tags: + - include: comment + - include: cdata + - include: tag + - include: entities + + tag-attributes: + - meta_prepend: true + - match: ^ + push: + - clear_scopes: 1 + - include: javadoc-asterisk diff --git a/Java/JavaProperties - Comments.tmPreferences b/Java/JavaProperties - Comments.tmPreferences new file mode 100644 index 0000000000..e5eec95f48 --- /dev/null +++ b/Java/JavaProperties - Comments.tmPreferences @@ -0,0 +1,25 @@ + + + + scope + source.java-props + settings + + shellVariables + + + name + TM_COMMENT_START + value + # + + + name + TM_COMMENT_START_2 + value + ! + + + + + diff --git a/Java/JavaProperties.sublime-syntax b/Java/JavaProperties.sublime-syntax index a9fae8ed7d..848553ed41 100644 --- a/Java/JavaProperties.sublime-syntax +++ b/Java/JavaProperties.sublime-syntax @@ -1,50 +1,63 @@ %YAML 1.2 --- -# http://www.sublimetext.com/docs/3/syntax.html +# https://en.wikipedia.org/wiki/.properties +# http://www.sublimetext.com/docs/syntax.html name: Java Properties +scope: source.java-props +version: 2 + file_extensions: - properties -scope: source.java-props -# https://en.wikipedia.org/wiki/.properties contexts: main: - - match: ^\s*([#!]).* - scope: comment.line.java-props + - match: ([#!]).*\n? captures: + 0: comment.line.java-props 1: punctuation.definition.comment.java-props + - match: (?=\S) + push: property-key + + property-key: + - meta_content_scope: meta.mapping.key.java-props entity.name.key.java-props + - include: line-continuation + - include: escapes + - match: \s*([:=]) + captures: + 1: punctuation.separator.mapping.key-value.java-props + set: maybe-property-value + - match: \s+(?=\S) + set: maybe-property-value + - match: \s*$ + pop: 1 + maybe-property-value: + - meta_include_prototype: false + - meta_scope: meta.mapping.java-props - match: (?=\S) - push: - - - meta_scope: meta.property.java-props - - match: '' - pop: true - - property - - property: - - meta_content_scope: entity.name.key.java-props - - include: backslash - - match: (?=[:=\s]) - set: - - match: '[:=]' - scope: punctuation.separator.java-props - set: property-value - - include: property-value - with_prototype: - - match: (?=\n) - pop: true + set: property-value + - include: eol-pop property-value: - - match: (?=\S) - set: - - meta_content_scope: string.unquoted.java-props - - include: backslash + - meta_content_scope: meta.mapping.value.java-props string.unquoted.java-props + - include: eol-pop + - include: escapes - backslash: - - match: (\\)\n - captures: - 1: punctuation.separator.continuation.java-props + escapes: - match: \\u[[:xdigit:]]{4} scope: constant.character.escape.unicode.java-props - match: \\[^u] scope: constant.character.escape.java-props + + eol-pop: + - include: line-continuation + - match: $ + pop: 1 + + line-continuation: + - match: (\\)\n + captures: + 1: punctuation.separator.continuation.java-props + push: + - match: ^ + pop: 1 diff --git a/Java/JavaScript (for JSP).sublime-syntax b/Java/JavaScript (for JSP).sublime-syntax new file mode 100644 index 0000000000..08308e4e12 --- /dev/null +++ b/Java/JavaScript (for JSP).sublime-syntax @@ -0,0 +1,32 @@ +%YAML 1.2 +--- +############################################################################### +# This intermediate syntax is used by `HTML (JSP).sublime-syntax` +# +# It powers Java highlighting within JSP tags in embedded JavaScript. +# +# +# +# The primary task is to add `jsp-embedded` context to JavaScript's +# prototype to match all the <% %> tags. +############################################################################### + +scope: source.js.embedded.jsp +version: 2 +hidden: true + +extends: Packages/JavaScript/JavaScript.sublime-syntax + +contexts: + + prototype: + - meta_prepend: true + - include: HTML (JSP).sublime-syntax#jsp-embedded + + string-content: + - meta_prepend: true + - include: HTML (JSP).sublime-syntax#jsp-interpolations diff --git a/Java/Symbol List - Inner Inner Class Methods.tmPreferences b/Java/Symbol List - Case Label.tmPreferences similarity index 50% rename from Java/Symbol List - Inner Inner Class Methods.tmPreferences rename to Java/Symbol List - Case Label.tmPreferences index 26fedfeb82..c2a984c077 100644 --- a/Java/Symbol List - Inner Inner Class Methods.tmPreferences +++ b/Java/Symbol List - Case Label.tmPreferences @@ -1,18 +1,18 @@ - name - Symbol List: Inner Inner Class Methods scope - source.java meta.class.body meta.class.body meta.class.body meta.method.identifier + source.java meta.statement.conditional.case.label.java settings showInSymbolList 1 symbolTransformation - s/\s{2,}/ /g; - s/.*/ $0/g; + s/\/\*.*?\*\///g; # remove block comments + s/\/\/[^\n]*\n//g; # remove line comments + s/\s+//g; # remove whitespace + s/^/case /; # prepend case keyword diff --git a/Java/Symbol List - Classes.tmPreferences b/Java/Symbol List - Classes.tmPreferences index f22d0f1fff..a2884fe965 100644 --- a/Java/Symbol List - Classes.tmPreferences +++ b/Java/Symbol List - Classes.tmPreferences @@ -1,12 +1,12 @@ - name - Symbol List: Classes scope - source.java meta.class meta.class.identifier + source.java meta.class.identifier entity.name.class settings + showInIndexedSymbolList + 1 showInSymbolList 1 diff --git a/Java/Symbol List - Constants.tmPreferences b/Java/Symbol List - Constants.tmPreferences index a6dffc7a21..bff544c226 100644 --- a/Java/Symbol List - Constants.tmPreferences +++ b/Java/Symbol List - Constants.tmPreferences @@ -1,8 +1,6 @@ - name - Symbol List: Constants scope source.java entity.name.constant.java settings diff --git a/Java/Indexed Symbol List.tmPreferences b/Java/Symbol List - Enums.tmPreferences similarity index 57% rename from Java/Indexed Symbol List.tmPreferences rename to Java/Symbol List - Enums.tmPreferences index 65a38934bf..2368884305 100644 --- a/Java/Indexed Symbol List.tmPreferences +++ b/Java/Symbol List - Enums.tmPreferences @@ -1,14 +1,14 @@ - name - Symbol List: Classes scope - source.java entity.name.class.java, source.java entity.name.function.java + source.java meta.enum.identifier entity.name.enum settings showInIndexedSymbolList 1 + showInSymbolList + 1 diff --git a/Java/Symbol List - Fields.tmPreferences b/Java/Symbol List - Fields.tmPreferences new file mode 100644 index 0000000000..96ceca2c55 --- /dev/null +++ b/Java/Symbol List - Fields.tmPreferences @@ -0,0 +1,12 @@ + + + + scope + source.java meta.field.identifier variable.other + settings + + showInSymbolList + 1 + + + diff --git a/Java/Symbol List - Imports.tmPreferences b/Java/Symbol List - Imports.tmPreferences new file mode 100644 index 0000000000..d7dd258ac7 --- /dev/null +++ b/Java/Symbol List - Imports.tmPreferences @@ -0,0 +1,21 @@ + + + + scope + source.java meta.import meta.path + settings + + showInIndexedSymbolList + 0 + showInSymbolList + 1 + symbolTransformation + + s/\/\*.*?\*\///g; # remove block comments + s/\/\/[^\n]*\n//g; # remove line comments + s/\s+//g; # remove whitespace + s/^/import /; # prepend import keyword + + + + diff --git a/Java/Symbol List - Inner Classes.tmPreferences b/Java/Symbol List - Inner Classes.tmPreferences deleted file mode 100644 index 412090efec..0000000000 --- a/Java/Symbol List - Inner Classes.tmPreferences +++ /dev/null @@ -1,16 +0,0 @@ - - - - name - Symbol List: Inner Classes - scope - source.java meta.class.body meta.class.identifier - settings - - showInSymbolList - 1 - symbolTransformation - s/.*/ $0/g - - - diff --git a/Java/Symbol List - Inner Inner Classes.tmPreferences b/Java/Symbol List - Inner Inner Classes.tmPreferences deleted file mode 100644 index 899123ab8a..0000000000 --- a/Java/Symbol List - Inner Inner Classes.tmPreferences +++ /dev/null @@ -1,16 +0,0 @@ - - - - name - Symbol List: Inner Inner Classes - scope - source.java meta.class.body meta.class.body meta.class.identifier - settings - - showInSymbolList - 1 - symbolTransformation - s/.*/ $0/g - - - diff --git a/Java/Symbol List - Interfaces.tmPreferences b/Java/Symbol List - Interfaces.tmPreferences new file mode 100644 index 0000000000..11d6233620 --- /dev/null +++ b/Java/Symbol List - Interfaces.tmPreferences @@ -0,0 +1,14 @@ + + + + scope + source.java meta.interface.identifier entity.name.interface + settings + + showInIndexedSymbolList + 1 + showInSymbolList + 1 + + + diff --git a/Java/Symbol List - Method.tmPreferences b/Java/Symbol List - Method.tmPreferences deleted file mode 100644 index b435782d80..0000000000 --- a/Java/Symbol List - Method.tmPreferences +++ /dev/null @@ -1,19 +0,0 @@ - - - - name - Symbol List: Methods - scope - source.java meta.class.body meta.method.identifier - settings - - showInSymbolList - 1 - symbolTransformation - - s/\s{2,}/ /g; - s/.*/ $0/g; - - - - diff --git a/Java/Symbol List - Modules.tmPreferences b/Java/Symbol List - Modules.tmPreferences index a7e471c315..b29b7d7715 100644 --- a/Java/Symbol List - Modules.tmPreferences +++ b/Java/Symbol List - Modules.tmPreferences @@ -1,14 +1,18 @@ - name - Symbol List: Modules scope - source.java meta.module meta.module.identifier + source.java meta.namespace.module.identifier & (meta.path, entity.name.namespace) settings showInSymbolList 1 + symbolTransformation + + s/\/\*.*?\*\///g; # remove block comments + s/\/\/[^\n]*\n//g; # remove line comments + s/\s+//g; # remove whitespace + diff --git a/Java/Symbol List - Inner Class Methods.tmPreferences b/Java/Symbol List - Packages.tmPreferences similarity index 51% rename from Java/Symbol List - Inner Class Methods.tmPreferences rename to Java/Symbol List - Packages.tmPreferences index ce5faf197a..666feab98f 100644 --- a/Java/Symbol List - Inner Class Methods.tmPreferences +++ b/Java/Symbol List - Packages.tmPreferences @@ -1,18 +1,17 @@ - name - Symbol List: Inner Class Methods scope - source.java meta.class.body meta.class.body meta.method.identifier + source.java meta.namespace.package.identifier & (meta.path, entity.name.namespace) settings showInSymbolList 1 symbolTransformation - s/\s{2,}/ /g; - s/.*/ $0/g; + s/\/\*.*?\*\///g; # remove block comments + s/\/\/[^\n]*\n//g; # remove line comments + s/\s+//g; # remove whitespace diff --git a/Java/Symbol List - Properties.tmPreferences b/Java/Symbol List - Properties.tmPreferences index 736aba798a..7d53ae4a4a 100644 --- a/Java/Symbol List - Properties.tmPreferences +++ b/Java/Symbol List - Properties.tmPreferences @@ -1,8 +1,6 @@ - name - Symbol List - Properties scope entity.name.key.java-props settings diff --git a/Java/syntax_test_java.java b/Java/syntax_test_java.java deleted file mode 100644 index 96d941314d..0000000000 --- a/Java/syntax_test_java.java +++ /dev/null @@ -1,2577 +0,0 @@ -// SYNTAX TEST "Packages/Java/Java.sublime-syntax" - -package apple; -// <- source.java meta.package-declaration.java keyword.other.package.java -// ^^^^^ entity.name.namespace.java -// ^ punctuation.terminator.java - -package com.example.apple; -//^^^^^^^^^^^^^^^^^^^^^^^ meta.package-declaration.java -// ^^^^^^^^^^^^^^^^^ entity.name.namespace.java -// ^ punctuation.accessor.dot.java -// ^ punctuation.accessor.dot.java -// ^ punctuation.terminator.java - -import a.b.Class; -// <- meta.import.java keyword.control.import.java -// ^^^^^^^^^ meta.path.java -// ^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^ support.class.import.java -// ^ punctuation.terminator.java - -import a.b.Class.SubClass; -//^^^^^^^^^^^^^^^^^^^^^^^ meta.import.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^ support.class.import.java - -import a.b.Class.*; -//^^^^^^^^^^^^^^^^ meta.import.java -// ^ punctuation.accessor.dot.java -// ^ keyword.operator.wildcard.asterisk.java - -import com.google -// ^^^^^^^^^^ meta.import.java meta.path.java -// ^ punctuation.accessor.dot.java -// ^^^^^^ support.type.package.java - .common.collect -//^ punctuation.accessor.dot.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^ support.type.package.java -//^^^^^^^^^^^^^^^ meta.import.java meta.path.java - .ListMultimap; -//^ punctuation.accessor.dot.java -// ^^^^^^^^^^^^ support.class.import.java -//^^^^^^^^^^^^^ meta.import.java meta.path.java -// ^ punctuation.terminator.java - -import no.terminator -// <- meta.import.java keyword.control.import.java - -import static no.terminator -// <- meta.import.java keyword.control.import.java - -import -// <- meta.import.java keyword.control.import.java - -import static -// <- meta.import.java keyword.control.import.java - -import java.net.URL; -// <- meta.import.java keyword.control.import.java -//^^^^^^^^^^^^^^^^^ meta.import.java -// ^^^^^^^^^^^^ meta.path.java -// ^^^ support.class.import.java -// ^^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^ punctuation.terminator.java - -import java.util.*; -//^^^^^^^^^^^^^^^^ meta.import.java -// ^^^^^^^^^^^ meta.path.java -// ^^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^ keyword.operator.wildcard.asterisk.java - -import static a.b.Class.fooMethod; -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.import.java -// <- meta.import.java keyword.control.import.java -// ^^^^^^ meta.import.java keyword.control.import.static.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^ meta.path.java -// ^^^^ support.class.import.java -// ^ punctuation.accessor.dot.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^ meta.import.java support.function.import.java -// ^ punctuation.terminator.java - -import static a.b.Class.CONSTANT; -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.import.java -// ^^^^^^^^^ meta.path.java -// ^^^^ support.class.import.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^ constant.other.import.java - -import static a.b.Class.*; -// ^ punctuation.accessor.dot.java -// ^ keyword.operator.wildcard.asterisk.java - -public class SyntaxTest { -//^^^^^^^^^^^^^^^^^^^^^^^ meta.class -// ^^^ storage.modifier.java -// ^^^^^ storage.type.java -// ^^^^^^^^^^ meta.class.identifier entity.name.class.java -// ^ - meta.class.identifier.java - meta.class.body.java -// ^ meta.class.body.java - private String memberString = "Hello"; - private String memberString2 = new String("Hello"); -// ^^^^^^ support.class.java - private String memberString3 = String.valueOf("Hello"); -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.assignment.rhs.java -// ^^^^^^^ storage.modifier.java -// ^^^^^^ support.class.java -// ^ keyword.operator.assignment.java -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.assignment.rhs.java -// ^^^^^^^ string.quoted.double.java -// ^ punctuation.definition.string.begin.java -// ^ punctuation.definition.string.end.java -// ^ - string.quoted.double.java -// ^ punctuation.terminator.java - meta.assignment.rhs.java - private int memberLpos = memberString3.indexOf("l"); -// ^^^ storage.type -// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.assignment.rhs.java -// ^^^ string -// ^ punctuation.terminator.java - - public static void main(String... args) { -// ^^^^^^^^^^^^^^^^^^^^^^^ meta.method -// ^^^^^^ storage.modifier.java -// ^^^^^^ storage.modifier.java -// ^^^^ storage.type -// ^^^^ meta.method.identifier.java entity.name.function.java -// ^^^^^^^^^^^^^^^^ meta.method.parameters.java -// ^ punctuation.section.parens.begin.java -// ^^^ keyword.operator.variadic.java -// ^^^^^ support.class.java -// ^^^^ variable.parameter.java -// ^ punctuation.section.parens.end.java -// ^ - meta.method.parameters -// ^ meta.method.body.java punctuation.section.block.begin.java - String[] strings = new String[5]; -// ^^^^^^^^^^^^^^ meta.assignment.rhs.java -// ^^^ keyword.other.storage.new.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java - printList(Arrays.stream(args) - .collect(Collectors.toCollection(ArrayList::new))); -// ^^^ meta.method.body.java - keyword.other.storage.new.java -// ^^^ variable.function.reference.java -// ^^ punctuation.accessor.double-colon.java - anotherMethod(); - try (Stream lines = Files.lines(path)) { -// ^^^ keyword.control.exception.try.java -// ^^^^^^^^^^^^^^^^^^ meta.assignment.rhs.java -// ^ - meta.parens.java -// ^ meta.method.body.java - meta.assignment.rhs.java - lines.forEach(System.out::println); -// ^^^^^^^ variable.function.reference.java - - } catch (IOException ignore) { -// ^^^^^^ meta.catch.java -// ^^^^^^^^^^^^^^^^^^^^ meta.catch.parameters.java meta.parens.java -// ^^^^^ keyword.control.exception.catch.java -// ^ punctuation.section.parens.begin.java -// ^^^^^^^^^^^ support.class.java -// ^^^^^^ variable.parameter -// ^ punctuation.section.parens.end.java - } catch (final MyException | com.net.org.Foo.Bar | -// ^^^^^^ meta.catch.java -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.catch.parameters.java meta.parens.java -// ^^^^^ keyword.control.exception.catch.java -// ^ punctuation.section.parens.begin -// ^ meta.catch.parameters storage.modifier.java -// ^^^^^^^^^^^ support.class -// ^ punctuation.separator.bar.java -// ^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^ support.class.java -// ^ punctuation.accessor.dot.java -// ^^^ support.class.java -// ^ punctuation.separator.bar.java - YourException ignore) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.catch -// ^ support.class -// ^ variable.parameter -// ^ meta.catch.parameters -// ^ punctuation.section.parens.end - - try (final InputStream is = new FileInputStream(args[0]); -// ^^^^^ storage.modifier - final OutputStream os = new FileOutputStream(args[1])) { -// ^^^^^ storage.modifier - - os.write(is.read()); -// ^^^^ variable.function - } - - try { -// ^^^ keyword.control.exception.try.java - Class.forName(args[2]); - } catch (Exception e) { -// ^^^^^ keyword.control.exception.catch.java - log.error(e); - } finally { -// ^^^^^^^ keyword.control.exception.finally.java - } - - for (final int x = 10;;) { System.out.println(x); break; } -// ^^^^^ storage.modifier - - for (int i = 0; i < 10; i+= 2) { -// ^^^ keyword.control -// ^^^ storage.type -// ^ keyword.operator.assignment.java -// ^^ meta.assignment.rhs.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.terminator.java - meta.assignment.rhs.java -// ^ keyword.operator.comparison.java -// ^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.terminator.java -// ^^ keyword.operator.assignment.java -// ^^ meta.assignment.rhs.java -// ^ - meta.assignment.rhs.java - System.out.println(i); - } - } -// ^ meta.method.java meta.method.body.java punctuation.section.block.end.java - private static void printList(List args) { -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method -// ^^^^^^^ storage.modifier.java -// ^^^^^^ storage.modifier.java -// ^^^^ storage.type -// ^^^^^^^^^ meta.method.identifier entity.name.function.java -// ^^^^^^^^^^^^^^^^^^^ meta.method.parameters -// ^^^^^^ support.class.java -// ^^^^ variable.parameter.java -// ^^ - meta.method.identifier.java -// ^^ meta.method.body.java - args.stream().forEach(System.out::println); -// ^^ punctuation.accessor.double-colon.java - } - - private static void anotherMethod() throws MyException { -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method -// ^^^^^^^ storage.modifier.java -// ^^^^^^ storage.modifier.java -// ^^^^ storage.type -// ^^^^^^^^^^^^^ meta.method.identifier entity.name.function.java -// ^^ meta.method.parameters -// ^^^^^^^^^^^^^^^^^^^^^^^ meta.method.throws -// ^^^^^^ keyword.declaration.throws.java -// ^^^^^ meta.generic.java -// ^^ meta.method.body.java -meta.method.throws - throw new MyException - ("hello (world)"); -// ^ - string - } - void save(T obj); -// ^^^^^^^^^^^ meta.method -// ^^^ meta.generic -// ^ variable.parameter.type -// ^^^^ storage.type -// ^^^^ meta.method.identifier -// ^^^^^^^ meta.method.parameters -} - -class ExtendsTest extends Foo {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class -// ^^^^^^^^^^^ meta.class.extends -// ^^^^^^^ keyword.declaration.extends.java -// ^^^ entity.other.inherited-class.java -// ^ - meta.class.extends - -class ExtendsTest implements Foo {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class -// ^^^^^^^^^^^^^^ meta.class.implements.java -// ^^^^^^^^^^ keyword.declaration.implements.java -// ^^^ entity.other.inherited-class.java -// ^ - meta.class.implements.java - -class Foo extends Bar {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class -// ^^^ meta.generic.declaration.java -// ^ variable.parameter.type.java -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.extends -// ^^^^^^^ keyword.declaration.extends.java - -class ExtendsAndImplementsTest extends Foo implements Bar, OtherBar {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class -// ^^^^^^^^^^^ meta.class.extends -// ^^^^^^^ keyword.declaration.extends.java -// ^^^ entity.other.inherited-class.java -// ^ - meta.class.extends -// ^^^^^^^^^^^^^^ meta.class.implements.java -// ^^^^^^^^^^ keyword.declaration.implements.java -// ^^^ entity.other.inherited-class.java -// ^^^^^ meta.generic.java -// ^ punctuation.separator.comma.java -// ^^^^^^^^ entity.other.inherited-class.java -// ^ - meta.class.implements.java - -class ExtendsAndImplementsTest extends Foo, Bar implements Bar, OtherBar {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class -// ^^^^^^^^^^^^^^^^^ meta.class.extends -// ^^^^^^^ keyword.declaration.extends.java -// ^^^ entity.other.inherited-class.java -// ^ punctuation.separator.comma.java -// ^^^ entity.other.inherited-class.java -// ^ - meta.class.extends -// ^^^^^^^^^^^^^^ meta.class.implements.java -// ^^^^^^^^^^ keyword.declaration.implements.java -// ^^^ entity.other.inherited-class.java -// ^^^^^ meta.generic.java -// ^ punctuation.separator.comma.java -// ^^^^^^^^ entity.other.inherited-class.java -// ^ - meta.class.implements.java - -class AnyClass { -// ^^^^^^^^ entity.name.class.java - int bar; // this comment() is recognized as code -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.line -// ^^ punctuation.definition.comment.java - - public void anyMethod(String finality){ -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method -// ^^^^^^^^^ meta.method.identifier -// ^^^^^^^^^^^^^^^^^ meta.method.parameters -// ^^^^^^^^ variable.parameter - storage.modifier -// ^^ meta.method.body.java - meta.method.identifier.java - System.out.println("Printed: " + finality); -// ^ keyword.operator - } - - public abstract void test(A thing); -// ^^^ meta.generic.declaration.java -// ^ variable.parameter.type.java - - public void test2(Type) abc -// ^^^ - variable.parameter -// ^ - meta.method.java -} -// <- punctuation.section.block.end.java - -interface T extends A, BB {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java -// ^^ meta.class.identifier.java -// ^^^^^^^^^^^^^^ meta.class.extends.java -// ^^ meta.class.body.java -// ^ entity.name.class.java -// ^^^^^^^ keyword.declaration.extends.java -// ^ entity.other.inherited-class.java -// ^ punctuation.separator.comma.java -// ^^ entity.other.inherited-class.java -// ^ punctuation.section.block.begin.java -// ^ punctuation.section.block.end.java - -public enum FooBaz { -// ^^^^ storage.type.java -//^^^^^^^^^^^^^^^^^^ meta.class -// ^^^^^^ meta.class.identifier.java entity.name.class.java -// ^ meta.class.body - // This is a test -// ^^^^^^^^^^^^^^^^^^ comment.line - UPLOAD("foo bar"), /* This a comment */ -// ^^^^^^ constant.other.enum -// ^^^^^^^^^ string.quoted.double.java -// ^^^^^^^^^^^^^^^^^^^^ comment.block -// ^ - comment.block - DELETE("baz"), -// ^^^^^^ constant.other.enum - // Comment here -// ^^^^^^^^^^^^^^^^ comment.line -} - -enum MyEnum { - FIRST_VALUE, // comment1 -//^^^^^^^^^^^ constant.other.enum -// ^^^^^^^^^^^ comment - MID_VALUE, // comment2 -//^^^^^^^^^ constant.other.enum -// ^^^^^^^^^^^ comment - LAST_VALUE // comment3 -//^^^^^^^^^^ constant.other.enum -// ^^^^^^^^^^^ comment -} - -public enum TokenKind extends MyEnum, FooBaz implements Foo, Bar { -//<- meta.class.java storage.modifier.java -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java -//^^^^ storage.modifier.java -// ^^^^ storage.type.java -// ^^^^^^^^^ entity.name.class.java -// ^^^^^^^ keyword.declaration.extends.java -// ^^^^^^ entity.other.inherited-class.java -// ^ punctuation.separator.comma.java -// ^^^^^^ entity.other.inherited-class.java -// ^^^^^^^^^^ keyword.declaration.implements.java -// ^^^ entity.other.inherited-class.java -// ^ punctuation.separator.comma.java -// ^^^ entity.other.inherited-class.java -// ^ punctuation.section.block.begin.java - a, -// ^ constant.other.enum.java -// ^ punctuation.separator.comma.java - a(1, 2, 3), -// ^ constant.other.enum.java -// ^^^^^^^^^ meta.parens.java -// ^ punctuation.section.parens.begin.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.separator.comma.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.separator.comma.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.parens.end.java -// ^ punctuation.separator.comma.java - a {}, -// ^ constant.other.enum.java -// ^ meta.block.java punctuation.section.block.begin.java -// ^ meta.block.java punctuation.section.block.end.java -// ^ punctuation.separator.comma.java - A, -// ^ constant.other.enum.java -// ^ punctuation.separator.comma.java - A(1), -// ^ constant.other.enum.java -// ^^^ meta.parens.java -// ^ punctuation.section.parens.begin.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.parens.end.java -// ^ punctuation.separator.comma.java - A {}, -// ^ constant.other.enum.java -// ^ meta.block.java punctuation.section.block.begin.java -// ^ meta.block.java punctuation.section.block.end.java -// ^ punctuation.separator.comma.java - integerToken, -// ^^^^^^^^^^^^ constant.other.enum.java -// ^ punctuation.separator.comma.java - integerToken("integer literal"), -// ^^^^^^^^^^^^^^^^^^^ meta.parens.java -// ^^^^^^^^^^^^ constant.other.enum.java -// ^ punctuation.section.parens.begin.java -// ^^^^^^^^^^^^^^^^^ string.quoted.double.java -// ^ punctuation.section.parens.end.java -// ^ punctuation.separator.comma.java - integerToken {}; -// ^^^^^^^^^^^^ constant.other.enum.java -// ^ meta.block.java punctuation.section.block.begin.java -// ^ meta.block.java punctuation.section.block.end.java -// ^ punctuation.terminator.java - int {} -// ^^^ storage.type.primitive.java - static {} -// ^^^^^^ storage.modifier.java - String image = ""; -// ^^^^^^ support.class.java -// ^^^^^ meta.field.java -// ^ keyword.operator.assignment.java -// ^^ string.quoted.double.java -// ^ punctuation.terminator.java - TokenKind(String s) {} -// ^^^^^^^^^^^^^^^^^^^^^^ meta.method.java -// ^^^^^^^^^ meta.method.identifier.java entity.name.function.constructor.java -// ^^^^^^^^^^ meta.method.parameters.java meta.parens.java -// ^^ meta.method.body.java -// ^ punctuation.section.parens.begin.java -// ^^^^^^ support.class.java -// ^ variable.parameter.java -// ^ punctuation.section.parens.end.java -// ^ punctuation.section.block.begin.java -// ^ punctuation.section.block.end.java - public static void main(String[]a){} -// ^^^^^^^^^^^^^^ meta.class.java meta.class.body.java meta.block.java -// ^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.class.body.java meta.block.java meta.method.java -// ^^^^ meta.method.identifier.java -// ^^^^^^^^^^^ meta.method.parameters.java meta.parens.java -// ^^ meta.method.body.java -// ^^^^^^ storage.modifier.java -// ^^^^^^ storage.modifier.java -// ^^^^ storage.type.void.java -// ^^^^ entity.name.function.java -// ^ punctuation.section.parens.begin.java -// ^^^^^^ support.class.java -// ^^ storage.modifier.array.java -// ^ variable.parameter.java -// ^ punctuation.section.parens.end.java -// ^ punctuation.section.block.begin.java -// ^ punctuation.section.block.end.java -} - -public // comment -//<- storage.modifier.java -enum // comment -//<- meta.class.java meta.class.identifier.java storage.type.java -TokenKind // comment -//<- meta.class.java meta.class.identifier.java entity.name.class.java -extends // comment -//<- meta.class.java meta.class.extends.java keyword.declaration.extends.java -MyEnum, // comment -//<- meta.class.java meta.class.extends.java entity.other.inherited-class.java -FooBaz // comment -//<- meta.class.java meta.class.extends.java entity.other.inherited-class.java -implements // comment -//<- meta.class.java meta.class.implements.java keyword.declaration.implements.java -Foo, // comment -//<- meta.class.java meta.class.implements.java entity.other.inherited-class.java -Bar // comment -//<- meta.class.java meta.class.implements.java entity.other.inherited-class.java -{ -//<- meta.class.java meta.class.body.java meta.block.java punctuation.section.block.begin.java -} -//<- meta.class.java meta.class.body.java meta.block.java punctuation.section.block.end.java - -class InvalidStuff -{ - goto -// ^^^^ invalid.illegal - - const int 3; -// ^^^^^ invalid.illegal -} - -public class Lambdas { - volatile int foo; -//^^^^^^^^ storage.modifier.java - - void anonymousFunctions() { - foo(); -// ^^^ variable.function.java - -// Capital names are usually used for classes - Foo(); -// ^^^ variable.function.java - - foo (); -// ^^^ variable.function.java - this.foo(); -// ^^^ variable.function.java -// ^^^ meta.generic.java -// ^ punctuation.definition.generic.begin.java -// ^ support.class.java - this. foo(); -// ^^^ variable.function.java -// ^^^ meta.generic.java -// ^ punctuation.definition.generic.begin.java -// ^ support.class.java - - Function func = a -> 42; -// ^^^^^^^^^ meta.assignment.rhs.java -// ^ variable.parameter.java -// ^^ storage.type.function.anonymous.java -// ^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.terminator.java - foo(a -> 42); -// ^^^^^^^^^^^^ meta.function-call.java -// ^^^ variable.function.java -// ^ punctuation.section.parens.begin.java -// ^ variable.parameter.java -// ^^ storage.type.function.anonymous.java -// ^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.parens.end.java -// ^ punctuation.terminator.java - - a -> { return 42; }; -// ^^^^^^^^^^^^^^ meta.function.anonymous.body.java - - (a, b) -> 42; -// ^ variable.parameter.java -// ^ variable.parameter.java -// ^^ storage.type.function.anonymous.java -// ^^ meta.number.integer.decimal.java constant.numeric.value.java - - (int a, Foo[] b) -> 42; -// ^^^ storage.type.primitive -// ^ variable.parameter.java -// ^^^ support.class.java -// ^ punctuation.definition.generic.begin.java -// ^^^^^^^ support.class.java -// ^ punctuation.definition.generic.end.java -// ^ variable.parameter.java -// ^^ storage.type.function.anonymous.java -// ^^ meta.number.integer.decimal.java constant.numeric.value.java - - // Lambda parameter tests - Function lambda1 = (final @MyAnnotation String foo) -> foo; -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java -// ^^^^^ storage.modifier.java -// ^^^^^^^^^^^^^ meta.annotation -// ^ punctuation.definition.annotation -// ^^^^^^ support.class.java - meta.annotation -// ^^^ variable.parameter.java -// ^^ storage.type.function.anonymous.java - meta.function.anonymous.parameters.java - - Function lambda2 = (@MyAnnotation String foo) -> foo; -// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java -// ^^^^^^^^^^^^^ meta.annotation -// ^ punctuation.definition.annotation -// ^^^^^^ support.class.java - meta.annotation -// ^^^ variable.parameter.java -// ^^ storage.type.function.anonymous.java - meta.function.anonymous.parameters.java - - Function lambda3 = (@MyAnnotation(foo = Foo.BAR) String foo) -> foo; -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation -// ^ punctuation.definition.annotation -// ^^^ variable.parameter.java -// ^^^ support.class.java -// ^ punctuation.accessor.dot.java -// ^^^ constant.other.java -// ^^^^^^ support.class.java - meta.annotation -// ^^^ variable.parameter.java -// ^^ storage.type.function.anonymous.java - meta.function.anonymous.parameters.java - - Function lambda4 = (String foo) -> foo; -// ^^^^^^^^^^^^ meta.function.anonymous.parameters.java -// ^^^^^^ support.class.java - meta.annotation -// ^^^ variable.parameter.java -// ^^ storage.type.function.anonymous.java - meta.function.anonymous.parameters.java - - Function lambda5 = (foo) -> foo; -// ^^^^^ meta.function.anonymous.parameters.java -// ^^^ variable.parameter.java -// ^^ storage.type.function.anonymous.java - meta.function.anonymous.parameters.java - - Function lambda6 = foo -> foo; -// ^^^ meta.function.anonymous.parameters.java -// ^^^ variable.parameter.java -// ^^ storage.type.function.anonymous.java - meta.function.anonymous.parameters.java - - Function lambda7 = (String... foo) -> foo[0]; -// ^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java -// ^^^^^^ support.class.java - meta.annotation -// ^^^ keyword.operator.variadic.java -// ^^^ variable.parameter.java -// ^^ storage.type.function.anonymous.java - meta.function.anonymous.parameters.java - - IntFunction intLambda1 = (int foo) -> String.valueOf(foo); -// ^^^^^^^^^ meta.function.anonymous.parameters.java -// ^^^ storage.type.primitive - meta.annotation -// ^^^ variable.parameter.java -// ^^ storage.type.function.anonymous.java - meta.function.anonymous.parameters.java - } -} - -class Generics { - - List field; -// ^^^^^^^^ meta.generic.java -// ^ punctuation.definition.generic.begin.java -// ^^^^^^ support.class.java -// ^ punctuation.definition.generic.end.java - - List field; -// ^^^^^^^^^^^^^^ meta.generic.java -// ^ punctuation.definition.generic.begin.java -// ^^^^^^^^^^^^ meta.path.java -// ^^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^ support.class.java - - void variableTypes() { - List x; -// ^^^^^^^^ meta.generic.java -// ^ punctuation.definition.generic.begin.java -// ^ punctuation.definition.generic.end.java - - List x; -// ^^^^^^^^^^^^^^^^^^ meta.generic.java -// ^^^^^^^^^^^^^^^^ meta.path.java -// ^^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^ support.class.java -// ^ punctuation.definition.generic.end.java - - List x; -// ^^^^^ meta.generic.java -// ^^^ support.class.java - - List x; -// ^^^^^^^^^^^^^^ meta.generic.java -// ^^^^^^^^^^^^ meta.path.java -// ^^^ support.class.java - - List x; -// ^^^^^^^ meta.generic.java -// ^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java - - List x; -// ^^^^^^^^^^^^^^^^^^^^ meta.generic.java -// ^^^^^^^^^^^^^^^^ meta.path.java -// ^^ storage.modifier.array.java - - List x; -// ^^^^^^^ meta.generic.java -// ^^^ support.class.java -// ^^ storage.modifier.array.java - - List[][] x; -// ^^^^^^^^^ meta.generic.java -// ^^^ storage.type.primitive.java -// ^^^^ storage.modifier.array.java -// ^^^^ storage.modifier.array.java - } - - void instantiation() { - - new Foo(); -// ^^^^^ meta.generic.java -// ^^^ support.class.java -// ^ punctuation.definition.generic.begin.java -// ^ punctuation.definition.generic.end.java - - new Foo(); -// ^ keyword.operator.wildcard.java - - new Foo(); -// ^ keyword.operator.wildcard.java -// ^^^ support.class.java -// ^^^^^^^ keyword.declaration.extends.java -// ^ punctuation.separator.comma.java - // ^^^^^^ support.class.java - - new Foo(); -// ^ keyword.operator.wildcard.java -// ^^^^^ keyword.declaration.super.java - - new Foo(); -// ^^^ -storage.type.primitive - - new Foo(); -// ^^^^^^ support.class.java -// ^^^ -storage.type.primitive - - new Foo(); -// ^^^^^^^^^^^^ meta.generic.java -// ^^^^^^^^^^ meta.path.java -// ^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^ support.type.package.java -// ^ punctuation.accessor.dot.java - - new Foo[] { new Foo(1), new Foo(2) }; -// ^^^ meta.generic.java -// ^^ punctuation.section.brackets -// ^ punctuation.section.braces.begin -// ^^^ support.class.java -// ^ punctuation.separator.comma.java -// ^^^ support.class.java -// ^ punctuation.section.braces.end - - new ArrayList[] { new ArrayList(), new ArrayList() } -// ^^^^^^^^^^^^^^^ meta.generic.java -// ^^^^^^^^^^^^^ meta.path.java -// ^^^^^^ meta.generic.java - - new a. -// ^^ meta.path.java - b.Foo(); -// ^^^^^ meta.generic.java meta.path.java - } -} - -public class Test { - - void test1() { - Foo.abc(); -// ^ punctuation.accessor.dot.java -// ^^^ variable.function.java - Foo.class; -// ^ punctuation.accessor.dot.java -// ^^^^^ variable.language.java - storage.type.java -// ^ punctuation.terminator.java - } - - void test2() { -// ^^^^^ entity.name.function.java - } -} - -@ClassName.FixMethodOrder( MethodSorters.NAME_ASCENDING ) -// <- meta.annotation punctuation.definition.annotation -meta.annotation.identifier -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation -//^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation.identifier -//^^^^^^^^ variable.annotation.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation.parameters -// ^ punctuation.accessor.dot -// ^ constant -public class GrafoTest { - @Override -// ^^^^^^^^^ meta.annotation -// ^ punctuation.definition.annotation -// ^^^^^^^^ variable.annotation.java - void test1() { -// ^ entity.name.function - } - - @Author(first = "Oompah", last = "Loompah") -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation -// ^ punctuation.definition.annotation -// ^^^^^^ meta.annotation.identifier variable.annotation.java -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation.parameters -// ^ punctuation.section.parens.begin -// ^^^^^ variable.parameter.java -// ^ keyword.operator -// ^^^^^^^^ string -// ^ punctuation.separator.comma.java -// ^^^^ variable.parameter.java -// ^ keyword.operator -// ^^^^^^^^ string -// ^ punctuation.section.parens.end - void test2() { -// ^ entity.name.function - - Grafo grafo = new Grafo( true ); - final Grafo temposMaisCedo = new Grafo( true ); -// ^ storage.modifier -// ^ support.class - } - - - @Partial @Mock(type=Grafo.class) DataLoader inline; -// ^^^^^^^^ meta.annotation -// ^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation -// ^ support.class - - @Override public int inline() { -// ^^^^^^^^^ meta.annotation -// ^ punctuation.definition.annotation -// ^^^^^^^^ variable.annotation - } - - void annotatedArgs(@NonNull final String p1, -// ^^^^^^^^ meta.annotation -// ^ storage.modifier - meta.annotation - @Named(value = "") List p2, @NonNull final String p3) {} -// ^^^^^^^^^^^^^^^^^^ meta.annotation -// ^ support.class -// ^ meta.generic punctuation.definition.generic.begin -// ^ variable.parameter -// ^ punctuation.separator -// ^^^^^^^^ meta.annotation -// ^ storage.modifier - meta.annotation -// ^ support.class - - List<@NotBlank(message = "") String> annotationInGeneric; -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.generic -// ^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation -// ^^^^^^ support.class - -} - -public enum FooEnum { -// ^^^^ storage.type.java - FOO; -//^^^ constant.other.enum -} -// <- meta.class.java meta.class.body.java punctuation.section.block.end.java - -public enum FooBarEnum { -// ^^^^ storage.type.java - FOO, -//^^^ constant.other.enum - BAR; -//^^^ constant.other.enum -} - -public enum AbstractEnum { -// ^^^^ storage.type.java - FOO { -//^^^ constant.other.enum -// ^ meta.enum.java meta.enum.body.java meta.block.java punctuation.section.block.begin.java - public void doSomething() { return; } -// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.java - }, -//^ meta.enum.java meta.enum.body.java meta.block.java punctuation.section.block.end.java - BAR { -//^^^ constant.other.enum - public void doSomething() { return; } -// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.java - }; - - public abstract void doSomething(); -// ^^^^^^^^^^^^^ meta.method.java -} - -public final class SomeClass extends BaseClass { -// ^ punctuation.definition.generic.begin.java -// ^ punctuation.definition.generic.end.java -// ^ punctuation.separator.comma.java -// ^ support.class.java -// ^ punctuation.section.block.begin.java -} - -public @interface PublicAnnotation { -// ^^^^^^^^^^ storage.type.java - int numericValue() default 42; -// ^^^^^^^ keyword.declaration.default.java -// ^^ constant.numeric - boolean booleanValue() default true; -// ^^^^^^^ keyword.declaration.default.java -// ^^^^ constant.language - char charValue() default 'S'; -// ^^^^^^^ keyword.declaration.default.java -// ^^^ string.quoted.single.java - String value() default "Default value"; -// ^^^^^^^ keyword.declaration.default.java -// ^^^^^^^^^^^^^^^ string.quoted.double.java - Class classValue() default String.class; -// ^^^^^^^ keyword.declaration.default.java -// ^^^^^^ support.class.java -// ^^^^^ variable.language.java - String[] arrayValue() default {"Foo", "Bar"}; -// ^^^^^^^ keyword.declaration.default.java -// ^ punctuation.section.block.begin -// ^^^^^ string.quoted.double.java -// ^^^^^ string.quoted.double.java -// ^ punctuation.section.block.end -} - -@interface PackageAnnotation {} -//^^^^^^^^ storage.type.java - -@MultiLineAnnotation( -// <- meta.annotation.java -// <- punctuation.definition.annotation.java -//^^^^^^^^^^^^^^^^^^ variable.annotation.java -// ^ meta.annotation.java meta.annotation.parameters.java punctuation.section.parens.begin.java - foo = BAR, -//^^^ variable.parameter.java -// ^ keyword.operator.assignment.java -// ^ constant.other.java -// ^ punctuation.separator.comma.java - other = "foo" -//^^^^^ variable.parameter.java -// ^ keyword.operator.assignment.java -// ^ string -) -// <- meta.annotation.java meta.annotation.parameters.java punctuation.section.parens.end.java -@fully.qualified.Annotation -// <- punctuation.definition.annotation.java -//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation.java meta.annotation.identifier.java meta.path.java -//^^^^ variable.annotation.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^ variable.annotation.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^ variable.annotation.java -@fully.qualified.ParentClass.InnerAnnotation -// <- punctuation.definition.annotation.java -//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation.java meta.annotation.identifier.java meta.path.java -//^^^^ variable.annotation.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^ variable.annotation.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^^^ variable.annotation.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^^^^^^^ variable.annotation.java -@fully.qualified -//^^^^^^^^^^^^^^ meta.annotation.identifier.java meta.path.java - .multiline.Annotation -// ^^^^^^^^^^^^^^^^^^^^^ meta.annotation.identifier.java meta.path.java - (foo = "bar") -// ^^^^^^^^^^^^^ meta.annotation.parameters.java -meta.annotation.identifier.java -@FancyAnnotation({ -// <- punctuation.definition.annotation.java -// ^^ meta.annotation.parameters.java - Foo.class, -//^^^ support.class.java -// ^ punctuation.accessor.dot.java -// ^^^^^ variable.language.java -// ^ punctuation.separator.comma.java - Bar.class -//^^^ support.class.java -// ^ punctuation.accessor.dot.java -// ^^^^^ variable.language.java -}) -// <- punctuation.section.braces.end.java - // <- meta.annotation.java meta.annotation.parameters.java punctuation.section.parens.end.java -class Bàr { -// ^^^ entity.name.class.java - Bàr() {} -//^^^^^ meta.method.java -//^^^ entity.name.function.constructor.java -} - -@AnnotationAsParameterSingle( - @Parameter(name = "foo") -// ^ punctuation.definition.annotation.java -// ^^^^^^^^^ variable.annotation.java -// ^^^^ variable.parameter.java -) - -@AnnotationAsParameterSingleNamed( - value = @Parameter(name = "foo") -//^^^^^ variable.parameter.java -// ^ punctuation.definition.annotation.java -// ^^^^^^^^ variable.annotation.java -// ^^^^ variable.parameter.java -) - -@AnnotationAsParameterMultiple({ -// ^ punctuation.section.braces.begin.java - @Parameter(name = "foo"), -// ^ punctuation.definition.annotation.java -// ^^^^^^^^^ variable.annotation.java -// ^^^^ variable.parameter.java - - @Parameter(name = "bar") -// ^ punctuation.definition.annotation.java -// ^^^^^^^^^ variable.annotation.java -// ^^^^ variable.parameter.java -}) -// <- punctuation.section.braces.end.java - -@AnnotationAsParameterMultipleNamed( - first = {@Parameter(name = "foo"), @Parameter(name = "bar")}, -//^^^^^ variable.parameter.java -// ^ punctuation.definition.annotation.java -// ^^^^^^^^^ variable.annotation.java -// ^^^^ variable.parameter.java -// ^ punctuation.definition.annotation.java -// ^^^^^^^^^ variable.annotation.java -// ^^^^ variable.parameter.java - second = {@Parameter(name = "foo"), @Parameter(name = "bar")}, -//^^^^^^ variable.parameter.java - third = @Parameter(name = "foo") -//^^^^^ variable.parameter.java -// ^^^^^^^^^ variable.annotation.java -) - -@SomeInterface -// <- punctuation.definition.annotation.java -public class Foo { -// <- meta.class.java storage.modifier.java -// ^ meta.class.java meta.class.identifier.java storage.type.java -// ^ punctuation.section.block.begin.java - - FooBar MY_CONST = new FooBar(); -// ^^^^^^^^ entity.name.constant.java - - @Inject -//^^^^^^^ meta.annotation - public Foo( -//^ - meta.annotation -// ^ meta.method.java -// ^ entity.name.function.constructor - // Comment for annotation - @MyAnnotation FooType annotatedParam, -// ^ meta.annotation.java -// ^ - meta.annotation.java -// ^ support.class.java -// ^ variable.parameter.java - String unannotatedParam) { -// ^ support.class.java -// ^ variable.parameter.java - return; -// ^^^^^^ keyword.control.flow.return.java - } - - void bar$() {} -// ^^^^^^ meta.method.java -// ^^^^ entity.name.function - - void à() {} -// ^^ meta.method.java -// ^ entity.name.function - - public static void main(String[] args, String moreArgs, a.b.c.Foo bar) {} -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.parameters.java -// ^^^^^^ support.class.java -// ^^ storage.modifier.array.java -// ^^^^ variable.parameter.java -// ^ punctuation.separator.comma.java -// ^^^^^^ meta.generic.java -// ^^^^^^ support.class.java -// ^^^^ support.class.java -// ^^^^^^^^ variable.parameter.java -// ^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^ punctuation.accessor.dot.java -// ^^^ support.class.java -// ^^^ variable.parameter.java - - MyClass myClass = new MyClass( - SomeEnum.ENUM_VALUE, - new OtherNewClass(), - new OtherNestedClass( - SomeEnum.ENUM_VALUE, - new SuperNestedClass(param, 2)), - anotherParam); - - public static final MyObject MY_CONST = new MyObject(), -// ^ entity.name.constant - - _MY_ANOTHER_CONST = new MyObject(); -// ^^^^^^^^^^^^^^^^^ entity.name.constant - - Object foo = new TypeLiteral< - StandardReferenceNumberProcessor< - SimpleGenerateReferenceNumberOperation, - SimpleSyncReferenceNumberOperation>>() {}; - - Object bar = SomeStaticClass.newBuilder().doThings(1) -// ^ meta.function-call.java variable.function.java -// ^ meta.function-call.java variable.function.java -// ^ meta.function-call.java meta.number.integer.decimal.java constant.numeric.value.java - .withString("I am a string"); -// ^ meta.function-call.java variable.function.java -// ^ meta.function-call.java string.quoted.double.java - - Object bah = someStaticMethodCall(4) -// ^ meta.function-call.java variable.function.java -// ^ meta.function-call.java meta.number.integer.decimal.java constant.numeric.value.java - .withString("I am a string"); -// ^ meta.function-call.java variable.function.java -// ^ meta.function-call.java string.quoted.double.java - - private static final String DEFAULT_IDEMPOTENCY_KEY = 44493; -// ^ entity.name.constant -// ^^^^^ meta.number.integer.decimal.java constant.numeric.value.java - - - private MyGenric, and.fully.Qualified, -// ^ meta.generic.java support.class.java -// ^ meta.generic.java punctuation.accessor.dot.java -// ^^^^^^^^^^^^^^^^^^^ meta.path.java - and.fully.Qualified> myVariable; -// ^^^^^^^^^^^^^^^^^^^ meta.path.java -// ^ meta.generic.java meta.generic.java support.class.java - - private MyObject otherObject = MY_CONST; -// ^ constant.other.java - - private MyObject otherObject = SOME_CONST.FOO; -// ^ constant.other.java -// ^ constant.other.java - - private MyObject otherObject = SOME_CONST.get(); -// ^ constant.other.java -// ^ variable.function.java - - private MyObject object = a.b.ErrorCode.COMMUNICATION_ERROR; -// ^^^^^^^^^^^^^ meta.path.java -// ^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^ support.type.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^ support.class.java -// ^ punctuation.accessor.dot.java -// ^ constant.other.java - - private static final UUID SECURE_ID = UUID.randomUUID(); -// ^ support.class.java -// ^ entity.name.constant -// ^ support.class.java -// ^ meta.function-call.java variable.function.java - - private URI uri = new URI(); -// ^^^ support.class.java -// ^^^ support.class.java - - private URI URI2 = new URI(); -// ^^^ support.class.java -// ^^^^ entity.name.constant.java -// ^^^ support.class.java - - - class SubClass extends AbstractClass.NestedClass { -// ^ entity.name.class.java -// ^^^^^^^^^^^^^ entity.other.inherited-class.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^^^ entity.other.inherited-class.java -// ^ punctuation.section.block.begin.java - } - - class SubClass extends AbstractClass { -// ^ entity.name.class.java -// ^ entity.other.inherited-class.java - } - - class SubClass extends fully.qualified -// ^ entity.name.class.java -// ^^^^^^^^^^^^^^^ meta.path.java -// ^^^^^ entity.other.inherited-class.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^ entity.other.inherited-class.package.java - .name.AbstractClass { -// ^^^^^^^^^^^^^^^^^^^ meta.path.java -// ^ punctuation.accessor.dot.java -// ^^^^ entity.other.inherited-class.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^^^^^ entity.other.inherited-class.java - } - - Function BLOCK_LAMBDA = r -> { -// ^ entity.name.constant -// ^ keyword.operator.assignment.java -// ^ storage.type.function.anonymous.java -// ^ meta.block punctuation.section.block.begin - return 1; -// ^^^^^^ keyword.control.flow.return.java - }; -//^ meta.block punctuation.section.block.end -// ^ punctuation.terminator - - Supplier supplier = () -> true; -// ^ punctuation.section.parens.begin.java -// ^ punctuation.section.parens.end.java -// ^ keyword.operator.assignment.java -// ^ storage.type.function.anonymous.java -// ^ punctuation.terminator - - byte[] byteArray; -//^^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java - - byte byteArray2[] = {1, 2}; -//^^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java -// ^^^^^^^^ meta.assignment.rhs.java - - static { -// ^ meta.static.body.java punctuation.section.block.begin.java - StaticFlag.setFlag("Boo!"); - } -//^ meta.static.body.java punctuation.section.block.end.java - - int operators() { - - assert scale > -100 : foo == true; -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.assertion.java -// ^^^^^^ keyword.control.flow.assert.java -// ^ punctuation.separator.expressions.java -// - if (this.scale<0) { -// ^^ keyword.control.conditional.if.java -// ^^^^^^^^^^^^^^ meta.parens.java -// ^ punctuation.section.parens.begin -// ^ punctuation.accessor.dot.java -// ^ keyword.operator.comparison.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ - meta.parens.java - return foo<<32; -// ^^^^^^ keyword.control.flow.return.java -// ^^ keyword.operator.bitshift.java -// ^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.terminator.java - } -// ^ meta.block.java punctuation.section.block.end.java - - int foo = true ? 1 : 2; -// ^^^^ constant.language.java -// ^ keyword.operator.ternary.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ keyword.operator.ternary.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.terminator.java - - return foo>> (c | 2); -// ^ keyword.operator.bitwise -// ^^^ keyword.operator.bitshift -// ^ keyword.operator.bitwise - - z &= x; z ^= x; z *= x; z /= x; -// ^^ keyword.operator.assignment -// ^^ keyword.operator.assignment -// ^^ keyword.operator.assignment -// ^^ keyword.operator.assignment - - } - - boolean inst = a instanceof Object; -// ^^^^^^^^^^ keyword.operator.word.instanceof - } -//^ meta.method.java meta.method.body.java punctuation.section.block.end.java - -/****************************************************************************** - * Numeric Constants Tests - *****************************************************************************/ - - int numbersTests() { - - a = 0x1.; -// ^^ meta.number.float.hexadecimal.java constant.numeric.base.java -// ^^ meta.number.float.hexadecimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java - - a = 0x.1a2f; -// ^^ meta.number.float.hexadecimal.java constant.numeric.base.java -// ^^^^^ meta.number.float.hexadecimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java - - a = 0x1.a2f; -// ^^ meta.number.float.hexadecimal.java constant.numeric.base.java -// ^^^^^ meta.number.float.hexadecimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java - - a = 0x1ffp+1023 0x1ffp+_1023_; -// ^^ meta.number.float.hexadecimal.java constant.numeric.base.java -// ^^^^^^^^^ meta.number.float.hexadecimal.java constant.numeric.value.java -// ^^ meta.number.float.hexadecimal.java constant.numeric.base.java -// ^^^^^^^^^^^ meta.number.float.hexadecimal.java constant.numeric.value.java - - a = 0xd.aP-1074 0x_1_f_._a_d_P-_10_74_; -// ^^ meta.number.float.hexadecimal.java constant.numeric.base.java -// ^^^^^^^^^ meta.number.float.hexadecimal.java constant.numeric.value.java -// ^^ meta.number.float.hexadecimal.java constant.numeric.base.java -// ^^^^^^^^^^^^^^^^^^^^ meta.number.float.hexadecimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ punctuation.separator.decimal.java - -// decimal floats - - a = 0D + 12345D + 12345D + 12_34_5_D - _12_34_5D - 12a45D; -// ^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^ - constant.numeric -// ^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^^^ - constant.numeric - - a = 0F + 12345F + 12345F + 12_34_5_F - _12_34_5F - 12a45F; -// ^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^ - constant.numeric -// ^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^^^ - constant.numeric - - a = 1. + 1_. + 1_2. - _1.; -// ^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^ - constant.numeric - - a = 1.D + 1_.D + 1_2.D - _1.D; -// ^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^ - constant.numeric - - a = 1.2 + 1_.2_ + 1_2.3_4 + 1_2_._3_4_ - _1.5; -// ^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^ - constant.numeric -// ^ punctuation.separator.decimal.java -// ^^ meta.number.float.decimal constant.numeric.value.java - - a = 1.2d + 1_.2_d + 1_2.3_4d + 1_2_._3_4_d - _1.5d; -// ^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^ - constant.numeric -// ^ punctuation.separator.decimal.java -// ^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java - - a = 12e34 + 12e+3_ + 1_2e3_4 + 1_2_e3_4_ + 1_2_e_3_4 + 12e+34 + 12e-34 + 12e+3_4 - _12e34; -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^^^^^^ - constant.numeric - - a = 12e34f + 12e+3_f + 1_2e3_4f + 1_2_e3_4_f + 1_2_e_3_4f + 12e+34f + 12e-34f + 12e+3_4f - _12e34f; -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^ - constant.numeric - - a = 12.e34 + 12.e+3_ + 1_2.e3_4 + 1_2_.e3_4_ + 1_2_.e_3_4 + 12.e+34 + 12.e-34 + 12.e+3_4 - _12.e34; -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^ - constant.numeric - - a = 12.e34f + 12.e+3_f + 1_2.e3_4f + 1_2_.e3_4_f + 1_2_.e_3_4f + 12.e+34f + 12.e-34f + 12.e+3_4f - _12.e34f; -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^ - constant.numeric - - a = 12.34e56 + 12_.34_e+5_ + 1_2.3_4e5_6 + 1_2_.3_4_e5_6_ + 1_2_._3_4e_5_6 + 12.34e+56 + 12.34e-56 + 12.34e+5_6 - _12.34e+5_6; -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^ - constant.numeric -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java - - a = 12.34e56f + 12_.34_e+5_f + 1_2.3_4e5_6f + 1_2_.3_4_e5_6_f + 1_2_._3_4e_5_6f + 12.34e+56f + 12.34e-56f + 12.34e+5_6f - _12.34e+5_6f; -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^ - constant.numeric -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java - - a = .2 + .2_ + .3_4 + ._3_4_; -// ^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java - - a = .2d + .2_d + .3_4d + ._3_4_d; -// ^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java - - a = .34e56 + .34_e+5_ + .3_4e5_6 + .3_4_e5_6_ + ._3_4e_5_6 + .34e+56 + .34e-56 + .34e+5_6; -// ^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java - - a = 23.45 + 23.45F + 23.45d; -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java - - a = .01 + .02e3+.02e3F; -// ^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ punctuation.separator.decimal.java -// ^ keyword.operator -// ^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ keyword.operator -// ^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java - - a = 23.45e67+23.45e+6F+23.45e-67D; -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ keyword.operator -// ^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java -// ^ keyword.operator -// ^^^^^^^^^ meta.number.float.decimal.java constant.numeric.value.java -// ^ meta.number.float.decimal.java constant.numeric.suffix.java - -// binary integers - - a = 0b101101 + 0b10_11_01 + 0b10_11_01_ + 0b_101101 - 0_b10_1101 + 0b; -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^^^^^^ meta.number.integer.binary.java constant.numeric.value.java -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^^^^^^^^ meta.number.integer.binary.java constant.numeric.value.java -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^^^^^^^^^ meta.number.integer.binary.java constant.numeric.value.java -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^^^^^^^ meta.number.integer.binary.java constant.numeric.value.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^^^^^^^^ - constant.numeric -// ^^ meta.number.integer.binary.java constant.numeric.base.java - - a = 0b101101l + 0b10_11_01l + 0b10_11_01_l + 0b_101101l - 0_b10_1101l + 0bl; -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^^^^^^ meta.number.integer.binary.java constant.numeric.value.java -// ^ meta.number.integer.binary.java constant.numeric.suffix.java -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^^^^^^^^ meta.number.integer.binary.java constant.numeric.value.java -// ^ meta.number.integer.binary.java constant.numeric.suffix.java -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^^^^^^^^^ meta.number.integer.binary.java constant.numeric.value.java -// ^ meta.number.integer.binary.java constant.numeric.suffix.java -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^^^^^^^ meta.number.integer.binary.java constant.numeric.value.java -// ^ meta.number.integer.binary.java constant.numeric.suffix.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^^^^^^^^^ - constant.numeric -// ^^ meta.number.integer.binary.java constant.numeric.base.java -// ^ meta.number.integer.binary.java constant.numeric.suffix.java - -// hexadecimal integers - - a = 0xABCD + 0xAB_CD + 0xAB_CD_ + 0x_AB_CD - 0_xAB_CD - 0x; -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java -// ^^^^ meta.number.integer.hexadecimal.java constant.numeric.value.java -// ^ keyword.operator.arithmetic.java -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java -// ^^^^^ meta.number.integer.hexadecimal.java constant.numeric.value.java -// ^ keyword.operator.arithmetic.java -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java -// ^^^^^^ meta.number.integer.hexadecimal.java constant.numeric.value.java -// ^ keyword.operator.arithmetic.java -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java -// ^^^^^^ meta.number.integer.hexadecimal.java constant.numeric.value.java -// ^ keyword.operator.arithmetic.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^^^^^^ - constant.numeric -// ^ keyword.operator.arithmetic.java -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java - - a = 0xABCDl + 0xAB_CDl + 0xAB_CD_l + 0x_AB_CDl - 0_xAB_CDl; -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java -// ^^^^ meta.number.integer.hexadecimal.java constant.numeric.value.java -// ^ meta.number.integer.hexadecimal.java constant.numeric.suffix.java -// ^ keyword.operator.arithmetic.java -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java -// ^^^^^ meta.number.integer.hexadecimal.java constant.numeric.value.java -// ^ meta.number.integer.hexadecimal.java constant.numeric.suffix.java -// ^ keyword.operator.arithmetic.java -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java -// ^^^^^^ meta.number.integer.hexadecimal.java constant.numeric.value.java -// ^ meta.number.integer.hexadecimal.java constant.numeric.suffix.java -// ^ keyword.operator.arithmetic.java -// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java -// ^^^^^^ meta.number.integer.hexadecimal.java constant.numeric.value.java -// ^ meta.number.integer.hexadecimal.java constant.numeric.suffix.java -// ^ keyword.operator.arithmetic.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^^^^^^^ - constant.numeric - -// octal integers - - a = 07 + 0_ + 0_7 + 07_ + 079 + 079_ + 0_79_ - 0a - 0_a; -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^^ meta.number.integer.octal.java constant.numeric.value.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^^ meta.number.integer.octal.java constant.numeric.value.java -// ^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ invalid.illegal.numeric.java -// ^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ invalid.illegal.numeric.java -// ^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^ invalid.illegal.numeric.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ - constant.numeric -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^ - constant.numeric - - a = 07l + 0_l + 0_7l + 07_l + 0792l + 079_2_l - 0al - 0_a_l; -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal constant.numeric.value.java -// ^ meta.number.integer.octal.java constant.numeric.suffix.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^ meta.number.integer.octal.java constant.numeric.suffix.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^^ meta.number.integer.octal.java constant.numeric.value.java -// ^ meta.number.integer.octal.java constant.numeric.suffix.java -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^^ meta.number.integer.octal.java constant.numeric.value.java -// ^ meta.number.integer.octal.java constant.numeric.suffix.java -// ^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ invalid.illegal.numeric.java -// ^ meta.number.integer.decimal.java constant.numeric.suffix.java -// ^^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ invalid.illegal.numeric.java -// ^ meta.number.integer.decimal.java constant.numeric.suffix.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^ - constant.numeric -// ^ meta.number.integer.octal.java constant.numeric.base.java -// ^ meta.number.integer.octal.java constant.numeric.value.java -// ^^^ - constant.numeric - -// decimal integers - - a = 0 + 0L; -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ meta.number.integer.decimal.java constant.numeric.suffix.java - - a = 12345 + 12_34_5 + 1_____5 + 12_34_5_ - _12_34_5 - 12a45; -// ^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^^^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^^^^^^^ - constant.numeric -// ^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^^ - constant.numeric - - a = 12345l + 12345L + 12_34_5_L - _12_34_5L - 12a45L; -// ^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ meta.number.integer.decimal.java constant.numeric.suffix.java -// ^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ meta.number.integer.decimal.java constant.numeric.suffix.java -// ^^^^^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ meta.number.integer.decimal.java constant.numeric.suffix.java -// ^^^^^^^^^ - constant.numeric -// ^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^^^^ - constant.numeric - - a = 123_-_456; -// ^^^^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ keyword.operator -// ^^^^ - constant.numeric - } - - String stringAndChars() { - String doubleQuotes = "String with double quotes"; -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ string.quoted.double -// ^ punctuation.definition.string.begin -// ^ punctuation.definition.string.end - - char singleQuotes = 'x'; -// ^^^ string.quoted.single -// ^ punctuation.definition.string.begin -// ^ punctuation.definition.string.end - - String escapes = "\b \t \n \f \r \" \' \\ \0 \12 \123 \u00e4 \uu00E4"; -// ^^^^^^^^^^^^^^^^^^^^^^^^^ string.quoted.double -// ^^ constant.character.escape -// ^^ constant.character.escape -// ^^ constant.character.escape -// ^^ constant.character.escape -// ^^ constant.character.escape -// ^^ constant.character.escape -// ^^ constant.character.escape -// ^^ constant.character.escape -// ^^ constant.character.escape.octal -// ^^^ constant.character.escape.octal -// ^^^^ constant.character.escape.octal -// ^^^^^^ constant.character.escape.unicode -// ^^^^^^^ constant.character.escape.unicode - - char escape = '\b' + '\t' + '\n' + '\f' + '\r' + '\"' + '\'' + '\\' + '\0' + '\12' + '\123' + '\u00e4' + '\uu00E4'; -// ^^^^ string.quoted.single -// ^^ constant.character.escape -// ^^^^ string.quoted.single -// ^^ constant.character.escape -// ^^^^ string.quoted.single -// ^^ constant.character.escape -// ^^^^ string.quoted.single -// ^^ constant.character.escape -// ^^^^ string.quoted.single -// ^^ constant.character.escape -// ^^^^ string.quoted.single -// ^^ constant.character.escape -// ^^^^ string.quoted.single -// ^^ constant.character.escape -// ^^^^ string.quoted.single -// ^^ constant.character.escape -// ^^^^ string.quoted.single -// ^^ constant.character.escape.octal -// ^^^^^ string.quoted.single -// ^^^ constant.character.escape.octal -// ^^^^^^ string.quoted.single -// ^^^^ constant.character.escape.octal -// ^^^^^^^^ string.quoted.single -// ^^^^^^ constant.character.escape.unicode -// ^^^^^^^^^ string.quoted.single -// ^^^^^^^ constant.character.escape.unicode - - String octalEscapesLimits = "\078 \456" -// ^^^ constant.character.escape.octal -// ^ -constant.character.escape.octal -// ^^^ constant.character.escape.octal -// ^ -constant.character.escape.octal - - String illegalEscapes = "\x \+ \8 \9" + '\x' + '\+' + '\8' + '\9' -// ^^^^^^^^^^^^^ string.quoted.double -// ^^ invalid.illegal.escape -// ^^ invalid.illegal.escape -// ^^ invalid.illegal.escape -// ^^ invalid.illegal.escape -// ^^^^ string.quoted.single -// ^^ invalid.illegal.escape -// ^^^^ string.quoted.single -// ^^ invalid.illegal.escape -// ^^^^ string.quoted.single -// ^^ invalid.illegal.escape -// ^^^^ string.quoted.single -// ^^ invalid.illegal.escape - - String text = "String without closing quote -// ^ invalid.illegal.newline - System.out.println(text); -// ^^^^^^ support.class - - char letter = 'z -// ^ invalid.illegal.newline - System.out.println(letter); -// ^^^^^^ support.class - } - - void varType() { - var x = "String"; -// ^^^ storage.type.var.java - - try (var in = new BufferedReader()) { -// ^^^ storage.type.var.java - var line = in.readLine(); -// ^^^ storage.type.var.java - } - } - - @Test -//^ punctuation.definition.annotation.java - public void someMethod(WithParam foo) throws Exception { -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.java -// ^^^^^^^^^^ meta.method.identifier.java entity.name.function.java -// ^ support.class.java -// ^ variable.parameter.java -// ^^^^^^^^^^^^^^^^ meta.method.throws.java -// ^^^^^^ keyword.declaration.throws.java -// ^^^^^^^^^ support.class.java -// ^ meta.method.java meta.method.body.java punctuation.section.block.begin.java - Object otherFoo = methodInvocation(foo); -// ^ support.class.java -// ^ keyword.operator.assignment.java -// ^ meta.function-call.java variable.function.java -// ^ punctuation.terminator.java - OtherObject bob = new OtherObject(foo); -// ^ keyword.other.storage.new.java -// ^ support.class.java - this.foo = new SubClass[0]; -// ^ keyword.other.storage.new.java -// ^ support.class.java -// ^^^ meta.brackets - - OuterClass.InnerClass foo = new OuterClass.InnerClass(); -// ^^^^^^^^^^ support.class.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^^ support.class.java - - String[][] doubleStringArray; -// ^^^^^^ support.class.java -// ^^^^ storage.modifier.array.java - - String[] stringArray = new String[] {"foo", "bar"}; -// ^^^^^^ support.class.java -// ^^ storage.modifier.array.java -// ^ keyword.operator.assignment.java -// ^^^ keyword.other.storage.new.java -// ^^^^^^ support.class.java -// ^ punctuation.section.brackets.begin.java -// ^ punctuation.section.brackets.end.java -// ^^^^^^^^^^^^^^ meta.braces.array-initialization.java -// ^ punctuation.section.braces.begin.java -// ^^^^^ string.quoted.double.java -// ^ punctuation.separator.comma.java -// ^^^^^ string.quoted.double.java -// ^ punctuation.section.braces.end.java -// ^ punctuation.terminator.java - - int[] data = new int[]{0, 0, 0}; -// ^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java -// ^^^ keyword.other.storage.new.java -// ^^^ storage.type.primitive.java -// ^ punctuation.section.brackets.begin.java -// ^ punctuation.section.brackets.end.java -// ^ punctuation.section.braces.begin.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.separator.comma.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.separator.comma.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.braces.end.java - - byte [] foo; -// ^^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java - byte []b=new byte[size]; -// ^^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java -// ^ keyword.operator.assignment.java -// ^^^ keyword.other.storage.new.java -// ^^^^ storage.type.primitive.java - - int[][][] threeDimArr = new int[][][] { -// ^^^ storage.type.primitive.java -// ^^^^^^ storage.modifier.array.java -// ^^^ storage.type.primitive.java -// ^ punctuation.section.brackets.begin.java -// ^ punctuation.section.brackets.end.java -// ^ punctuation.section.brackets.begin.java -// ^ punctuation.section.brackets.end.java -// ^ punctuation.section.brackets.begin.java -// ^ punctuation.section.brackets.end.java -// ^ punctuation.section.braces.begin.java - { { 1, 2 }, { 3, 4 } }, -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.separator.comma.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.braces.begin.java -// ^ punctuation.section.braces.end.java -// ^ punctuation.separator.comma.java - { { 5, 6 }, { 7, 8 } } -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.separator.comma.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.braces.begin.java -// ^ punctuation.section.braces.end.java - }; -// ^ punctuation.section.braces.end.java - - threeDimArr = new int[1][3][4]; -// ^^^ storage.type.primitive.java -// ^^^^^^^^^ meta.brackets.array-initialization.java -// ^ punctuation.section.brackets.begin.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.brackets.end.java -// ^ punctuation.section.brackets.begin.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.brackets.end.java -// ^ punctuation.section.brackets.begin.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.brackets.end.java - - bob = new some.path.to.MyObject[3]; -// ^^^^^^^^^^^^^^^^^^^^^ meta.path.java -// ^^^^^^^^ support.class.java -// ^^^ meta.brackets.array-initialization.java -// ^ punctuation.section.brackets.begin.java -// ^ meta.number.integer.decimal.java constant.numeric.value.java -// ^ punctuation.section.brackets.end.java - - foo.forEach((k, v) -> { -// ^ storage.type.function.anonymous.java -// ^ punctuation.section.block.begin - - return; -// ^^^^^^ keyword.control.flow.return.java -// ^ punctuation.terminator - }); -// ^ punctuation.section.block.end.java -// ^ punctuation.terminator - this.foo = new SubClass(new SubClass[0], true); -// ^ keyword.other.storage.new.java -// ^ support.class.java -// ^^^ meta.brackets -// ^ constant.language.java -/* We can't support this yet.*/ - some.other.path. -/* ^^^^^^^^^^^^^^^^ support.class.java */ - foo.MyClass.staticMethod(true); -/* ^^^^^^^^^^^ support.class.java */ - - some.other.path -/* ^^^^^^^^^^^^^^^ support.class.java */ - .foo.MyClass.staticMethod(true); -/* ^^^^^^^^^^^^ support.class.java */ - - @MyAnnotation -// ^ punctuation.definition.annotation.java -// ^^^^^^^^^^^^^ meta.annotation.java - int foo; - } -//^ meta.method.java meta.method.body.java punctuation.section.block.end.java - - void arrayMethod(byte [] [] a, int b, byte[] c) {} -//^^^^ storage.type.void.java -// ^^^^^^^^^^^ entity.name.function.java -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.parameters.java -// ^ - meta.method.parameters.java -// ^^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java -// ^^ storage.modifier.array.java -// ^ variable.parameter.java -// ^^^ storage.type.primitive.java -// ^ variable.parameter.java -// ^^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java -// ^ variable.parameter.java - - int[] arrayMethod2(int a[], String b[]) {} -//^^^ storage.type.primitive.java -// ^^ storage.modifier.array.java -// ^^^ storage.type.primitive.java -// ^ variable.parameter.java -// ^^ storage.modifier.array.java -// ^^^^^^ support.class.java -// ^ variable.parameter.java -// ^^ storage.modifier.array.java - - void arrayOfGenericMethod(Map[] mapping) {} -// ^^ storage.modifier.array.java -// ^^^^^^^ variable.parameter.java - - void primitiveVarArgs(int... values) {} -// ^^^ storage.type.primitive.java -// ^^^ keyword.operator.variadic.java -// ^^^ variable.parameter.java - - public class Foo {} - // ^^^^^^^^^^^^^^^ meta.generic.declaration.java - // ^ variable.parameter.type.java - // ^^^^^^^ keyword.declaration.extends.java - // ^^^ - storage.type.primitive.java - - @RunWith(JUnit4.class) -//^ punctuation.definition.annotation.java -// ^^^^^^^^^^^^^^ meta.annotation.parameters.java -// ^ support.class.java -// ^ variable.language.java - public void someReallyReallyLongMethodNameThatMakesTheBraceOverflowToTheNextLine( -// ^ meta.method.java meta.method.identifier.java entity.name.function.java -// ^ punctuation.section.parens.begin - WITHSOMEPARAMS foo, -// ^ meta.method.java meta.method.parameters.java support.class.java -// ^ meta.method.java meta.method.parameters.java variable.parameter.java - Generic bar) -// ^ meta.method.java meta.method.parameters.java support.class.java -// ^^^^^^^ meta.generic.java -// ^ meta.method.java meta.method.parameters.java variable.parameter.java -// ^ punctuation.section.parens.end - throws Exception { -// ^ meta.method.java meta.method.throws.java keyword.declaration.throws.java -// ^ meta.method.java meta.method.throws.java support.class.java - return someMethod(new Function() { -// ^ meta.class.body.anonymous.java punctuation.section.braces.begin.java - @Override - public V apply(V input) { -// ^ support.class.java -// ^^^^^^^^^ meta.method.parameters.java -// ^ support.class.java -// ^ variable.parameter.java -// ^ meta.method.body - return input; - } -// ^ meta.method.body - }, executor); -// ^ meta.class.body.anonymous.java punctuation.section.braces.end.java -// ^ meta.function-call.java punctuation.section.parens.end.java - } -//^ meta.method.body.java punctuation.section.block.end.java - - public static T writeAll(Collection, Sink) {} -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.java -// ^^^ meta.generic.declaration.java -// ^ variable.parameter.type.java -// ^ - meta.generic.java -// ^ support.class.java -// ^ support.class.java -// ^^^^^^^^^^^^^ meta.generic.java -// ^ punctuation.definition.generic.begin.java -// ^ keyword.operator.wildcard.java -// ^ keyword.declaration.extends.java -// ^ support.class.java -// ^ punctuation.definition.generic.end.java -// ^ punctuation.separator.comma.java - meta.generic.java -// ^^^ meta.generic.java - - public static > -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.generic.declaration.java -// ^ variable.parameter.type.java -// ^^^^^^^^^^ support.class.java -// ^ punctuation.definition.generic.begin.java -// ^ keyword.operator.wildcard.java -// ^ keyword.declaration.super.java -// ^ support.class.java -// ^ punctuation.definition.generic.end.java -// ^ punctuation.definition.generic.end.java -// ^^^^^^^^^^^ meta.generic.java - T max(Collection coll); -// ^ support.class.java - - public static Set unmodifiableSet(Set set); -// ^^^ meta.generic.declaration.java -// ^ variable.parameter.type.java - - public void -// ^ storage.type.void.java - methodNameOnDifferentLine(); -// ^ meta.method.identifier.java entity.name.function.java - - void myAbstractMethod(With foo); -// ^ meta.method.java meta.method.identifier.java entity.name.function.java - - private Long myOtherAbstractMethod(@WithAnnotation Blah blah); -// ^ meta.method.java meta.method.identifier.java entity.name.function.java -// ^ meta.method.java meta.method.parameters.java punctuation.definition.annotation.java - - public MyGeneric otherAbstractMethod(Foo bar); -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.generic.java -// ^ - meta.generic.java -// ^ support.class.java -// ^ support.class.java -// ^ support.class.java -// ^ support.class.java -// ^ support.class.java -// ^ meta.method.java meta.method.identifier.java entity.name.function.java - - public static void myGenericMethod(SomeType root) -// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.generic.declaration.java -// ^ punctuation.definition.generic.begin.java -// ^ variable.parameter.type.java -// ^ keyword.declaration.extends.java -// ^ support.class.java -// ^ storage.type.void.java -// ^entity.name.function.java - - throws Exception, IOException, SAXException { -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.throws -// ^ - meta.method.throws - } -}} -// <- meta.class.java meta.class.body.java punctuation.section.block.end.java - //<- invalid.illegal.stray-brace-end - -public -// <- storage.modifier.java -class IOException { } -// <- storage.type.java - -public class Generic implements fully.qualified.Other { -// ^^^^^^^^^^^^^^^^^^^^^ meta.path.java -// ^^^^^ entity.other.inherited-class.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^^^^^ entity.other.inherited-class.package.java -// ^ punctuation.accessor.dot.java -// ^^^^^ entity.other.inherited-class.java -// ^^^ meta.generic.java -// ^ punctuation.definition.generic.begin.java -// ^ support.class.java -// ^ punctuation.definition.generic.end.java -} -// <- punctuation.section.block.end.java - -public class Generic extends iNtf implements iNterface { -// ^^^^ entity.other.inherited-class.java -// ^^^^^^^^^ entity.other.inherited-class.java -// ^^^ meta.generic.java -// ^ punctuation.definition.generic.begin.java -// ^ support.class.java -// ^ punctuation.definition.generic.end.java -} -// <- punctuation.section.block.end.java - -public class Bar { - public void missingSemiColon() { - boolean foo = foo -// ^^^^ meta.assignment.rhs.java - } -//^ punctuation.section.block.end.java - - private SomeClass methodWithBadParens( - CombinedServerSpec vendorManagementServerSpec; -// ^ invalid.illegal.missing-parameter-end - - public void strayParans() { -// ^ punctuation.section.block.begin.java - foo.bar(hello(world); -// ^ invalid.illegal.stray-terminator-end - } -//^ punctuation.section.block.end.java - - public void strayParansInBlock() { -// ^ punctuation.section.block.begin.java - if (hello(world) { -// ^ invalid.illegal -// ^ - meta.parens.java -// ^ meta.block.java - return false; - } - } - - public void strayParansInForLoop() { -// ^ punctuation.section.block.begin.java - for (;; { -// ^ invalid.illegal -// ^ meta.block.java - meta.parens.java - } - } -//^ punctuation.section.block.end.java - - public void strayParansInConstructor() { -// ^ punctuation.section.block.begin.java - return new Foo(; -// ^ invalid.illegal - } -//^ punctuation.section.block.end.java - - private boolean missingSemiColonForStaticAssignment = true -// ^^^^ meta.assignment.rhs.java - - public void strayParansInConstructor() { -//^^^^^^ meta.class.body.java storage.modifier.java - meta.assignment.rhs.java -// ^ meta.method.identifier.java entity.name.function.java -// ^ punctuation.section.block.begin.java - return; - } - - private boolean missingSemiColonForStaticAssignmentPackageProtected = true -// ^^^^ meta.assignment.rhs.java - - void strayParansInConstructor() { -//^^^^ storage.type.void.java - meta.assignment.rhs.java -// ^ meta.method.identifier.java entity.name.function.java -// ^ punctuation.section.block.begin.java - return; - } -//^ punctuation.section.block.end.java -} -// <- punctuation.section.block.end.java - -class Javadoc { - - /** This is javadoc, not a simple comment */ -//^^^ punctuation.definition.comment.begin.javadoc -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.block.documentation.javadoc -// ^^ punctuation.definition.comment.end.javadoc - - /** -//^^^ comment.block.documentation.javadoc punctuation.definition.comment.begin.javadoc - * Description of some sort. -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.block.documentation.javadoc - */ -// ^^ comment.block.documentation.javadoc punctuation.definition.comment.end.javadoc - - /** - *

Before tag -// ^ punctuation.definition.comment.javadoc - *{@value} Before inline tag -// ^ punctuation.definition.comment.javadoc - *@return Before block tag -// ^ punctuation.definition.comment.javadoc - */ - - /** - * Unclosed html tag:

  • - - - -// ^^^^^^^^^^^^^^^ meta.tag - - - <%@ include file="foo.bar" %> -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.directive -// ^^^ punctuation.section.directive -// ^^ punctuation.section.directive - - Plain text -// ^^^^^^^^^^ text.html.jsp - meta - - <%-- This is a comment --%> -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.block.jsp - <% -// ^^ punctuation.section.embedded.begin.jsp - source.java.embedded.html -// ^ source.java.embedded.html - if (!foo && !bar) { -// ^^ keyword.control.conditional.if.java -// ^ keyword.operator.logical.java -// ^^ keyword.operator.logical.java - %>
    <% -// ^^ punctuation.section.embedded.end.jsp - source.java.embedded.html -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag -// ^^ punctuation.section.embedded.begin.jsp - source.java.embedded.html - if (foot.shouldBe()) { -// ^^ keyword.control.conditional.if.java - boolean test = false; -// ^^^^^^^ storage.type -// ^^^^^ constant - %> -// ^^ punctuation.section.embedded.end.jsp - source.java.embedded.html -// ^ text.html.jsp - source.java.embedded.html - - <%-- This is a comment --%> -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.block.jsp - <% int aNumber = 0; // this scriptlet should close %> -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.line.double-slash.java -// ^^ punctuation.section.embedded.end.jsp - - -
    -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag - <% -// ^^ punctuation.section.embedded.begin.jsp - source.java.embedded.html - } -// ^ - invalid.illegal.stray-brace-end - } -// ^ - invalid.illegal.stray-brace-end - %> -// ^^ punctuation.section.embedded.end.jsp - source.java.embedded.html -// ^ text.html.jsp - source.java.embedded.html - - diff --git a/Java/tests/syntax_test_java.java b/Java/tests/syntax_test_java.java new file mode 100644 index 0000000000..3c3deda679 --- /dev/null +++ b/Java/tests/syntax_test_java.java @@ -0,0 +1,10549 @@ +// SYNTAX TEST "Packages/Java/Java.sublime-syntax" + +/****************************************************************************** + * Comment Tests + *****************************************************************************/ + +// Comment +// <- comment.line.double-slash.java punctuation.definition.comment.java + // <- comment.line.double-slash.java punctuation.definition.comment.java +//^^^^^^^^^ comment.line.double-slash.java - punctuation + +/////////////////////////////////////////////////////////////////////////////// +// <- comment.line.double-slash.java punctuation.definition.comment.java +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.line.double-slash.java punctuation.definition.comment.java + +/// Comment /////////////////////////////////////////////////////////////////// +// <- comment.line.double-slash.java punctuation.definition.comment.java +//^ comment.line.double-slash.java punctuation.definition.comment.java +// ^^^^^^^^^ comment.line.double-slash.java - punctuation +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.line.double-slash.java punctuation.definition.comment.java + + /**/ /***/ /****/ /* **/ +//^ - comment +// ^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^ - comment +// ^^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^ - comment +// ^^^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^^ comment.block.java punctuation.definition.comment.begin.java +// ^ comment.block.java - punctuation +// ^^^ comment.block.java punctuation.definition.comment.end.java +// ^ - comment + + /* +//^ - comment +// ^^ comment.block.java punctuation.definition.comment.begin.java +// ^ comment.block.java - punctuation + * +// ^ comment.block.java punctuation.definition.comment.java +// ^ comment.block.java - punctuation + */ +// ^ comment.block.java - punctuation +// ^^ comment.block.java punctuation.definition.comment.end.java +// ^ - comment + +/****************************************************************************** + * JavaDoc Tests + *****************************************************************************/ + + /** This is javadoc, not a simple comment */ +//^^^ punctuation.definition.comment.begin.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.block.documentation.java +// ^^ punctuation.definition.comment.end.java + + /** +//^^^ comment.block.documentation.java punctuation.definition.comment.begin.java + * Description of some sort. +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.block.documentation.java + */ +// ^^ comment.block.documentation.java punctuation.definition.comment.end.java + + /** + *

    Description that starts with tag +// ^^^ comment.block.documentation.java meta.tag + */ + + /** One-liner with tags */ +// ^^^ comment.block.documentation.java meta.tag +// ^^^ comment.block.documentation.java meta.tag + + /** @param onFirstLine @param +//^^^ comment.block.documentation.java punctuation.definition.comment.begin.java +// ^^^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^ - entity.name.tag.documentation.javadoc + * @param normal @param +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^ - entity.name.tag.documentation.javadoc + * +// ^ comment.block.documentation.java punctuation.definition.comment.java + @param withoutAsterisk @param +// ^^^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^ - entity.name.tag.documentation.javadoc + */ +// ^^ comment.block.documentation.java punctuation.definition.comment.end.java + + /** + * Parameters + * + * @param paramName Some description +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^^^^ variable.parameter.javadoc + * that spans several lines. +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^ meta.tag +// ^^^^ meta.tag +// ^ punctuation.definition.comment.java + * + * @param + * paramName1 +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^^^^^^^ variable.parameter.javadoc + * Parameter description + * + * @param + * paramName2 +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^^^^^^^ variable.parameter.javadoc + * + * @param + * @param + * paramName3 +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^^^^^^^ variable.parameter.javadoc + */ +// ^^ comment.block.documentation.java punctuation.definition.comment.end.java + + /** Not a @param tag */ +// ^^^^^^^^^^^^^^^^^^^^^^ comment.block.documentation.java +// ^^^^^^ - entity.name.tag.documentation.javadoc + + /** + * Code blocks +// ^ comment.block.documentation.java punctuation.definition.comment.java + * + * {@code} {@literal} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^ - meta.tag +// ^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^ entity.name.tag.documentation.javadoc +// ^ punctuation.definition.tag.end.javadoc +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^^^ entity.name.tag.documentation.javadoc +// ^ punctuation.definition.tag.end.javadoc + * + * {@code List lst = new ArrayList<>()} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^ entity.name.tag.documentation.javadoc +// ^ - markup.raw.javadoc +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.raw.javadoc +// ^ punctuation.definition.tag.end.javadoc + * {@code text} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^ entity.name.tag.documentation.javadoc +// ^ - markup.raw.javadoc +// ^^^^^^^^^^^^^^^^^^^^^^^ markup.raw.javadoc +// ^ punctuation.definition.tag.end.javadoc + * + * Multiline, line break in content: {@code x + y +// ^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^^^^^ markup.raw.javadoc +// ^ - meta.tag - markup.raw.javadoc + * = z} +// ^ comment.block.documentation.java punctuation.definition.comment.java +//^^^ - meta.tag - markup.raw.javadoc +// ^^^ meta.tag.inline.javadoc markup.raw.javadoc +// ^ meta.tag.inline.javadoc - markup.raw + * + * Multiline, line break before content: {@literal +// ^ - markup.raw.javadoc + * x + y = z} +// ^ comment.block.documentation.java punctuation.definition.comment.java +//^^^ - meta.tag - markup.raw.javadoc +// ^^^^^^^^^ meta.tag.inline.javadoc markup.raw.javadoc +// ^ meta.tag.inline.javadoc - markup.raw + * + * Bracket balancing: {@code int[][] a = {{1, 2, 3}, {4, 5}}} +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.raw.javadoc +// ^ punctuation.definition.tag.end.javadoc + * + * Bracket balancing with line break: {@code int[][] a = { +// ^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^^^^^^^^ markup.raw.javadoc +// ^ - markup.raw.javadoc + * {1, 2, 3}, {4, 5}}} +// ^ comment.block.documentation.java punctuation.definition.comment.java +//^^^ - meta.tag - markup.raw.javadoc +// ^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc markup.raw.javadoc +// ^ meta.tag.inline.javadoc - markup.raw +// ^ - meta.tag +// ^ punctuation.definition.tag.end.javadoc + */ + + /** + * Inline tags with references + * + * {@link} {@linkplain} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^ - meta.tag +// ^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^ entity.name.tag.documentation.javadoc +// ^ punctuation.definition.tag.end.javadoc +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^^^^^ entity.name.tag.documentation.javadoc +// ^ punctuation.definition.tag.end.javadoc + * + * {@link Class} {@linkplain org.package.Class} {@link org.package.Class.NestedClass} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^ - meta.tag +// ^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^ entity.name.tag.documentation.javadoc +// ^^^^^ markup.underline.link.javadoc +// ^ punctuation.definition.tag.end.javadoc +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^^^^ entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc +// ^ punctuation.definition.tag.end.javadoc +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc +// ^ punctuation.definition.tag.end.javadoc + * + * Method separator: + * {@link package.Class#method} {@linkplain #method} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^ - markup.underline +// ^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc +// ^^^^^^^^^^^^^^ - markup.underline +// ^^^^^^^ markup.underline.link.javadoc +// ^^ - markup.underline + * + * Brackets: + * {@link Class#method(Type, Type)} {@link #method(Type, Type) label} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc +// ^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc +// ^^^^^ meta.label.javadoc - markup.underline.link.javadoc + * + * Line breaks: + * {@link Class#method(Type, + * Type, Type) label} +// ^ comment.block.documentation.java punctuation.definition.comment.java +//^^^ - meta.tag.inline - markup.underline +// ^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^ markup.underline.link.javadoc +// ^ - markup +// ^^^^^ meta.label.javadoc +// ^^ - markup + * + * {@link + * Class#method(Type, Type, Type) label} +// ^ comment.block.documentation.java punctuation.definition.comment.java +//^^^ - meta.tag.inline - markup.underline +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc +// ^ - markup +// ^^^^^ meta.label.javadoc +// ^^ - markup + * + * {@link Class#method(Type, Type, Type) + * label} +// ^ comment.block.documentation.java punctuation.definition.comment.java +//^^^ - meta.tag.inline - markup.underline +// ^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^ meta.label.javadoc +// ^^ - markup + * + * Tags in label: + * {@link Class#method(Type, Type, Type) label} +// ^^^^^^^^^^^^ meta.label.javadoc +// ^^^ meta.tag +// ^^^^ meta.tag + * + * {@value} {@value #SOME_CONSTANT} {@value package.Class#SOME_CONSTANT} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^ - meta.tag +// ^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.javadoc +// ^ - meta.tag +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^ entity.name.tag.documentation.javadoc +// ^ punctuation.definition.tag.end.javadoc +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^ entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^ markup.underline.link.javadoc +// ^ punctuation.definition.tag.end.javadoc +// ^ punctuation.definition.tag.begin.javadoc +// ^^^^^^ entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc +// ^ punctuation.definition.tag.end.javadoc + */ + + /** + * Block tags with reference + * + * @see Class#method(Type, Type) +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc + * + * @see java.util.stream +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^^^^^^^^^^^^^ - markup.underline.link.javadoc +// ^^^ meta.tag +// ^^^ meta.tag + * + * @see 'java.util.stream' +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^^^^^^^^ - markup.underline.link.javadoc + * + * @see https://wiki.xmldation.com/Support/Validator/ETagUnterminated +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc + * + * @throws IOException +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^ markup.underline.link.javadoc + + * @throws IOException because IOException +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^^^^ meta.tag.block.javadoc entity.name.tag.documentation.javadoc +// ^^^^^^^^^^^ markup.underline.link.javadoc +// ^^^^^^^^^^^^^^^^^^^ - markup.underline.link.javadoc + * + * @unknown {@code test} +// ^ comment.block.documentation.java punctuation.definition.comment.java +// ^^^^^^^^ - keyword +// ^^^^^^^^^^^^ meta.tag.inline.javadoc + */ +// ^^ comment.block.documentation.java punctuation.definition.comment.end.java + + /** + * Leading asterisk with space +// ^ punctuation.definition.comment.java + *Without space +// ^ punctuation.definition.comment.java + *

    Before tag +// ^ punctuation.definition.comment.java + *{@value} Before inline tag +// ^ punctuation.definition.comment.java + *@return Before block tag +// ^ punctuation.definition.comment.java + */ + + /** + * class {@literal Set>} +// ^^^^^^ meta.tag.html +// ^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.html +// ^^^^^^^ meta.tag.html + */ + + /** + * Levenshtein distance algorithm from http://www.merriampark.com/ld.htm +//^^^ comment.block.documentation.java - meta.tag +// ^ punctuation.definition.comment.java +// ^ meta.tag punctuation.definition.tag.end.html + * +//^^^^^^^^^^^^^ comment.block.documentation.java +// ^ punctuation.definition.comment.java +// ^^^^^^^^^ meta.tag + */ + + /** + * Unclosed html tag:

  • +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^^ variable.parameter.type.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java + +class generictest +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^^ variable.parameter.type.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java + +class GenericTest +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^ punctuation.section.generic.begin.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java + +class GenericTest +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^ punctuation.section.generic.begin.java +// ^ invalid.illegal.unexpected-keyword.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java + +class GenericTest +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^ punctuation.section.generic.begin.java +// ^ invalid.illegal.unexpected-keyword.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.section.generic.end.java + +class GenericTest +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^ punctuation.section.generic.begin.java +// ^ variable.parameter.type.java +// ^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java + +class GenericTest +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^ punctuation.section.generic.begin.java +// ^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java + +class GenericTest<@Anno A extends @Anno com . @Anno Foo & @Anno Foo . @Anno Bar> +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java meta.generic.java +// ^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java meta.generic.java +// ^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java meta.generic.java +// ^ meta.class.identifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^ meta.class.identifier.java - meta.generic +// ^ punctuation.section.generic.begin.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ variable.parameter.type.java +// ^^^^^^^ storage.modifier.extends.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ keyword.operator.logical.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^ keyword.declaration.super.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^ storage.type.class.java +// ^^ punctuation.section.generic.end.java + +class generictest<@anno a extends @anno com . @anno foo & @anno foo . @anno bar> +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java meta.generic.java +// ^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java meta.generic.java +// ^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^^^^^^^^^^^^^^^ meta.class.identifier.java meta.generic.declaration.java meta.generic.java +// ^ meta.class.identifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^ meta.class.identifier.java - meta.generic +// ^ punctuation.section.generic.begin.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ variable.parameter.type.java +// ^^^^^^^ storage.modifier.extends.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ keyword.operator.logical.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^ keyword.declaration.super.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^ storage.type.class.java +// ^^ punctuation.section.generic.end.java + +class GenericTest extends Foo {} +//<- meta.class.java keyword.declaration.class.java +//^^^ meta.class.java - meta.class meta.class +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.generic - meta.class meta.class +// ^^^ meta.class.identifier.java meta.generic.declaration.java - meta.class meta.class +// ^ meta.class.identifier.java - meta.generic - meta.class meta.class +// ^^^^^^^^^^^ meta.class.extends.java - meta.generic - meta.class meta.class +// ^^^^^^^^^^^^^ meta.class.extends.java meta.generic.java - meta.class meta.class +// ^ meta.class.extends.java - meta.generic - meta.class meta.class +// ^^ meta.class.java meta.block.java - meta.class meta.class +//^^^ keyword.declaration.class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^^ entity.name.class.java +// ^^^^ - entity - keyword - storage +// ^ punctuation.section.generic.begin.java +// ^ variable.parameter.type.java +// ^ punctuation.section.generic.end.java +// ^^^^^^^ storage.modifier.extends.java +// ^ - entity - keyword - storage +// ^^^ entity.other.inherited-class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^^^ storage.modifier.extends.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ - entity - keyword - storage +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +class GenericTest extends @Anno com . @Anno Foo<@Anno ? extends @Anno SuperClass . @Anno SubClass & @Anno OtherClass>, @Anno OuterClass {} +//^^^ meta.class.java - meta.class meta.class +// ^^^^^^^^^^^^ meta.class.identifier.java - meta.generic - meta.class meta.class +// ^^^ meta.class.identifier.java meta.generic.declaration.java - meta.class meta.class +// ^ meta.class.identifier.java - meta.generic - meta.class meta.class +// ^^^^^^^^^^^^^^ meta.class.extends.java - meta.class meta.class - meta.generic - meta.path +// ^^^^^^^^^^^^^^^ meta.class.extends.java meta.path.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.extends.java meta.generic.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^^ meta.class.extends.java - meta.class meta.class - meta.generic +// ^^ meta.class.java meta.block.java - meta.class meta.class +//^^^ keyword.declaration.class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^^ entity.name.class.java +// ^^^^ - entity - keyword - storage +// ^ punctuation.section.generic.begin.java +// ^ variable.parameter.type.java +// ^ punctuation.section.generic.end.java +// ^^^^^^^ storage.modifier.extends.java +// ^ - entity - keyword - storage +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.section.generic.begin.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ variable.language.wildcard.java +// ^^^^^^^ storage.modifier.extends.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^^ storage.type.class.java +// ^ keyword.operator.logical.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.separator.comma.java +// ^ - entity - keyword - storage - variable +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ - entity - keyword - storage - variable +// ^^^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +class ImplementsTest implements +//^^^ meta.class.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class +// ^^^^^^^^^^^ meta.class.implements.java - meta.class meta.class +//^^^ keyword.declaration.class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^^^^^ entity.name.class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^ storage.modifier.implements.java + +class ImplementsTest implements Foo {} +//^^^ meta.class.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class +// ^^^^^^^^^^^^^^^ meta.class.implements.java - meta.class meta.class +// ^^ meta.class.java meta.block.java - meta.class meta.class +//^^^ keyword.declaration.class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^^^^^ entity.name.class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^ storage.modifier.implements.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +class lowercasetest implements fully.qualified.other { +//^^^ meta.class.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.implements.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^ meta.class.java meta.block.java - meta.class meta.class +//^^^ keyword.declaration.class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^^^^ entity.name.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.parameter.type.java +// ^ punctuation.section.generic.end.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^ storage.modifier.implements.java +// ^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^ entity.other.inherited-class.java +// ^^^ meta.generic.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +} +// <- punctuation.section.block.end.java + +volatile class extends implements {} +//<- meta.class.java invalid.illegal.unexpected-keyword.java +//^^^^^^^^^^^^ meta.class.java - meta.class meta.class +//^^^^^^ invalid.illegal.unexpected-keyword.java +// ^ meta.class.identifier.java - meta.class meta.class +// ^^^^^^^^ meta.class.extends.java - meta.class meta.class +// ^^^^^^^^^^^ meta.class.implements.java - meta.class meta.class +// ^^ meta.class.java meta.block.java - meta.class meta.class +// ^^^ +// ^ - entity - keyword - storage +// ^^^^^^^ storage.modifier.extends.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^ storage.modifier.implements.java +// ^ - entity - keyword - storage +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +class ExtendsAndImplementsTest extends Foo implements Bar, OtherBar {} +//^^^ meta.class.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class +// ^^^^^^^^^^^^ meta.class.extends.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.implements.java - meta.class meta.class +// ^^ meta.class.java meta.block.java - meta.class meta.class +//^^^ keyword.declaration.class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^^^^^^^^^^^^^^^ entity.name.class.java +// ^ - entity - keyword - storage +// ^^^^^^^ storage.modifier.extends.java +// ^ - entity - keyword - storage +// ^^^ entity.other.inherited-class.java +// ^ - entity - keyword - storage +// ^^^^^^^^^^ storage.modifier.implements.java +// ^ - entity - keyword - storage +// ^^^ entity.other.inherited-class.java +// ^^^^^ meta.generic.java +// ^ punctuation.separator.comma.java +// ^^ - entity - keyword - storage +// ^^^^^^^^ entity.other.inherited-class.java +// ^ - entity - keyword - storage +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +class ExtendsAndImplementsTest extends Foo, bar implements bar, OtherBar {} +//^^^ meta.class.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.identifier.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^ meta.class.extends.java - meta.class meta.class +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.implements.java - meta.class meta.class +// ^^ meta.class.java meta.block.java - meta.class meta.class +//^^^ keyword.declaration.class.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ entity.name.class.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.separator.comma.java +// ^^^ entity.other.inherited-class.java +// ^^^^^^^^^^ storage.modifier.implements.java +// ^^^ entity.other.inherited-class.java +// ^^^^^ meta.generic.java +// ^ punctuation.separator.comma.java +// ^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +class AnyClass{AnyClass(){}} +//^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.class meta.class +//^^^ meta.class.java +// ^^^^^^^^^ meta.class.identifier.java +// ^^^^^^^^^^^^^^ meta.class.java meta.block.java +// ^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^^ meta.function.java meta.block.java +//^^^ keyword.declaration.class.java +// ^^^^^^^^ entity.name.class.java +// ^ punctuation.section.block.begin.java +// ^^^^^^^^ entity.name.function.constructor.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^ punctuation.section.block.end.java + +class anyclass{anyclass(){}} +//^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.class meta.class +//^^^ meta.class.java +// ^^^^^^^^^ meta.class.identifier.java +// ^^^^^^^^^^^^^^ meta.class.java meta.block.java +// ^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^^ meta.function.java meta.block.java +//^^^ keyword.declaration.class.java +// ^^^^^^^^ entity.name.class.java +// ^ punctuation.section.block.begin.java +// ^^^^^^^^ entity.name.function.constructor.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^ punctuation.section.block.end.java + +class AnyClass { // comment +//^^^ meta.class.java keyword.declaration.class.java +// ^^^^^^^^^^ meta.class.identifier.java +// ^^^^^^^^^^^^^ meta.class.java meta.block.java +// ^^^^^^^^ entity.name.class.java +// ^ punctuation.section.block.begin.java +// ^^^^^^^^^^^^ comment.line.double-slash.java + + const class NestedClass { +// ^^^^^ invalid.illegal.keyword.java +// ^^^^^ meta.class.java meta.block.java meta.class.java keyword.declaration.class.java +// ^^^^^^^^^^^^^ meta.class.java meta.block.java meta.class.identifier.java +// ^^ meta.class.java meta.block.java meta.class.java meta.block.java +// ^^^^^^^^^^^ entity.name.class.java +// ^ punctuation.section.block.begin.java + + void declareLocalClasses() { + + class +// ^^^^^ meta.class.java meta.class.java meta.class.java +// ^ meta.class.java meta.class.java meta.class.identifier.java +// ^^^^^ keyword.declaration.class.java + + class LocalClass +// ^^^^^ meta.class.java meta.class.java meta.class.java +// ^^^^^^^^^^^^ meta.class.java meta.class.java meta.class.identifier.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^^^ entity.name.class.java + + static class LocalClass +// ^^^^^^^^^^^^ meta.class.java meta.class.java meta.class.java +// ^^^^^^^^^^^^ meta.class.java meta.class.java meta.class.identifier.java +// ^^^^^^ storage.modifier.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^^^ entity.name.class.java + + final class LocalClass extends OtherClass { +// ^^^^^^^^^^^ meta.class.java meta.class.java meta.class.java +// ^^^^^^^^^^^^ meta.class.java meta.class.java meta.class.identifier.java +// ^^^^^^^^^^^^^^^^^^^ meta.class.java meta.class.java meta.class.extends.java +// ^^ meta.class.java meta.class.java meta.class.java meta.block.java +// ^^^^^ storage.modifier.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^^^ entity.name.class.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java + public class LocalNestedClass; +// ^^^^^^^^^^^^ meta.class.java meta.class.java meta.class.java meta.class.java +// ^^^^^^^^^^^^^^^^^ meta.class.java meta.class.java meta.class.java meta.class.identifier.java +// ^^^^^^ storage.modifier.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^^^^^^^^^ entity.name.class.java +// ^ punctuation.terminator.java + } +// ^ punctuation.section.block.end.java + } +// ^ punctuation.section.block.end.java + + void classReferences() { + Foo.class; // comment +// ^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java - storage.type.java +// ^ punctuation.terminator.java +// ^^^^^^^^^^^ comment.line.double-slash.java + super.class; +// ^^^^^ variable.language.super.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java - storage.type.java +// ^ punctuation.terminator.java + + this.class; +// ^^^^ variable.language.this.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java - storage.type.java +// ^ punctuation.terminator.java + + this +// ^^^^ variable.language.this.java + /**/ . +// ^^^^ comment.block.empty.java +// ^ punctuation.accessor.dot.java + /**/ class +// ^^^^ comment.block.empty.java +// ^^^^^ variable.language.class.java - storage.type.java + /**/ ; +// ^^^^ comment.block.empty.java +// ^ punctuation.terminator.java + } + } +// ^ meta.class.java meta.block.java meta.class.java meta.block.java punctuation.section.block.end.java +// ^ meta.class.java meta.block.java - meta.class meta.class + + class SubClass extends AbstractClass { +// ^^^^^ meta.class.java meta.block.java meta.class.java +// ^^^^^^^^^^ meta.class.java meta.block.java meta.class.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.class.extends.java +// ^^ meta.class.java meta.block.java meta.class.java meta.block.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^ entity.name.class.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^^^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java + } +// ^ meta.class.java meta.block.java meta.class.java meta.block.java punctuation.section.block.end.java + + class subclass extends abstractclass { +// ^^^^^ meta.class.java meta.block.java meta.class.java +// ^^^^^^^^^^ meta.class.java meta.block.java meta.class.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.class.extends.java +// ^^ meta.class.java meta.block.java meta.class.java meta.block.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^ entity.name.class.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^^^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java + } +// ^ meta.class.java meta.block.java meta.class.java meta.block.java punctuation.section.block.end.java + + class SubClass extends AbstractClass.NestedClass { +// ^^^^^ meta.class.java meta.block.java meta.class.java +// ^^^^^^^^^^ meta.class.java meta.block.java meta.class.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.class.extends.java +// ^^ meta.class.java meta.block.java meta.class.java meta.block.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^ entity.name.class.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^^^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java + } +// ^ meta.class.java meta.block.java meta.class.java meta.block.java punctuation.section.block.end.java + + class subclass extends abstractclass.nestedclass { +// ^^^^^ meta.class.java meta.block.java meta.class.java +// ^^^^^^^^^^ meta.class.java meta.block.java meta.class.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.class.extends.java +// ^^ meta.class.java meta.block.java meta.class.java meta.block.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^ entity.name.class.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^^^^^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java + } +// ^ meta.class.java meta.block.java meta.class.java meta.block.java punctuation.section.block.end.java + + protected class SubClass extends fully.qualified +// ^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.class.java +// ^^^^^^^^^^ meta.class.java meta.block.java meta.class.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.class.extends.java +// ^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ variable.namespace.java + .name.AbstractClass { +// ^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.class.extends.java +// ^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^^^ entity.other.inherited-class.java + } +// ^ meta.class.java meta.block.java meta.class.java meta.block.java punctuation.section.block.end.java +} +//<- meta.class.java meta.block.java punctuation.section.block.end.java + +@Anno // comment +//<- meta.class.java meta.annotation.identifier.java punctuation.definition.annotation.java +public // comment +//<- meta.class.java storage.modifier.java +class // comment +//<- meta.class.java +TestClass // comment +//<- meta.class.identifier.java entity.name.class.java +extends // comment +//<- meta.class.extends.java storage.modifier.extends.java +MyClass, // comment +//<- meta.class.extends.java entity.other.inherited-class.java +FooBaz // comment +//<- meta.class.extends.java entity.other.inherited-class.java +implements // comment +//<- meta.class.implements.java storage.modifier.implements.java +Foo, // comment +//<- meta.class.implements.java entity.other.inherited-class.java +Bar // comment +//<- meta.class.implements.java entity.other.inherited-class.java +{ +//<- meta.class.java meta.block.java punctuation.section.block.begin.java +} +//<- meta.class.java meta.block.java punctuation.section.block.end.java + + +/****************************************************************************** + * Eumeration Declaration Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.9 + *****************************************************************************/ + +enum$ ; +// <- meta.variable.identifier.java variable.other.java +//^^^ meta.variable.identifier.java variable.other.java + +$enum ; +// <- meta.variable.identifier.java variable.other.java +//^^^ meta.variable.identifier.java variable.other.java + +enum +//<- meta.enum.java keyword.declaration.enum.java +//^^ meta.enum.java keyword.declaration.enum.java + +enum EnumTest +//<- meta.enum.java keyword.declaration.enum.java +//^^ meta.enum.java keyword.declaration.enum.java +// ^^^^^^^^^^ meta.enum.identifier.java +// ^ - entity - keyword - storage +// ^^^^^^^^ entity.name.enum.java +// ^ - entity + +enum EnumTest {} +//<- meta.enum.java keyword.declaration.enum.java +//^^ meta.enum.java keyword.declaration.enum.java +// ^^^^^^^^^^ meta.enum.identifier.java +// ^^ meta.enum.java meta.block.java +// ^ - entity - keyword - storage +// ^^^^^^^^ entity.name.enum.java +// ^ - entity +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +public enum EnumTest { int {} } +//^^^^^^^^^ meta.enum.java +// ^^^^^^^^^^ meta.enum.identifier.java +// ^^^^^^^^^^ meta.enum.java meta.block.java +// ^^^^ +// ^ - entity - keyword - storage +// ^^^^^^^^ entity.name.enum.java +// ^ - entity - punctuation +// ^ punctuation.section.block.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// ^ punctuation.section.block.end.java + +public enum EnumTest {FOO, BAR} +//^^^^^^^^^ meta.enum.java +// ^^^^^^^^^^ meta.enum.identifier.java +// ^^^^^^^^^^ meta.enum.java meta.block.java +// ^^^^ +// ^ - entity - keyword - storage +// ^^^^^^^^ entity.name.enum.java +// ^ - entity - punctuation +// ^ punctuation.section.block.begin.java +// ^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.separator.comma.java +// ^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.section.block.end.java + +public enum EnumTest permits OtherClass {FOO, BAR} +//^^^^^^^^^ meta.enum.java +// ^^^^^^^^^^ meta.enum.identifier.java +// ^^^^^^^^^^^^^^^^^^^ meta.enum.permits.java +// ^^^^^^^^^^ meta.enum.java meta.block.java +// ^^^^ +// ^ - entity - keyword - storage +// ^^^^^^^^ entity.name.enum.java +// ^ - entity - punctuation +// ^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^^^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java +// ^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.separator.comma.java +// ^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.section.block.end.java + +public enum FooEnum { +//^^^^^^^^^ meta.enum.java +// ^^^^^^^^^ meta.enum.identifier.java +// ^^ meta.enum.java meta.block.java +//^^^^ storage.modifier.java +// ^^^^ +// ^^^^^^^ entity.name.enum.java +// ^ punctuation.section.block.begin.java + FOO; +//^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.terminator.java - meta.constant +} +// <- meta.enum.java punctuation.section.block.end.java + +public enum FooBarEnum { +//^^^^^^^^^ meta.enum.java +// ^^^^^^^^^^^^ meta.enum.identifier.java +// ^^ meta.enum.java meta.block.java +// ^^^^ +// ^^^^^^^^^^ entity.name.enum.java +// ^ punctuation.section.block.begin.java + FOO, +//^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.separator.comma.java + BAR; +//^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.terminator.java - meta.constant +} +// <- meta.enum.java punctuation.section.block.end.java + +public enum FooBarBazEnum { +//^^^^^^^^^ meta.enum.java +// ^^^^^^^^^^^^^^^ meta.enum.identifier.java +// ^^ meta.enum.java meta.block.java +// ^^^^ +// ^^^^^^^^^^^^^ entity.name.enum.java +// ^ punctuation.section.block.begin.java + FOO, // comment +//^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.separator.comma.java +// ^^^^^^^^^^^ comment.line.double-slash.java + BAR, /* comment */ +//^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.separator.comma.java +// ^^^^^^^^^^^^^ comment.block.java + BAZ // comment +//^^^ meta.constant.identifier.java entity.name.constant.java +// ^^^^^^^^^^^ comment.line.double-slash.java +} +// <- meta.enum.java punctuation.section.block.end.java + +protected enum IllegalTypeParam & T> {} +//<- meta.enum.java storage.modifier.java +//^^^^^^^^^^^^ meta.enum.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.enum.identifier.java +// ^^ meta.enum.java meta.block.java +//^^^^^^^ storage.modifier.java +// ^^^^ keyword.declaration.enum.java +// ^^^^^^^^^^^^^^^^ entity.name.enum.java +// ^^^^^^^^^^^^^^^^^^^^^^^ invalid.illegal.unexpected-type-parameters.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +public enum TokenKind extends MyEnum, FooBaz> implements Foo, Bar { +//<- meta.enum.java storage.modifier.java +//^^^^^^^^^ meta.enum.java +// ^^^^^^^^^^^^^^ meta.enum.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.enum.extends.java +// ^^^^^^^^^^^^^^^^^^^^ meta.enum.implements.java +// ^^ meta.enum.java meta.block.java +//^^^^ storage.modifier.java +// ^^^^ +// ^^^^^^^^^ entity.name.enum.java +// ^^^ invalid.illegal.unexpected-type-parameters.java +// ^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^^^^ entity.other.inherited-class.java +// ^ punctuation.separator.comma.java +// ^^^^^^ entity.other.inherited-class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^^^^^ meta.generic.java - meta.generic meta.generic +// ^ variable.language.wildcard.java +// ^^^^^ keyword.declaration.super.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ meta.generic.java meta.generic.java +// ^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ meta.generic.java punctuation.section.generic.end.java - meta.generic meta.generic +// ^^^^^^^^^^ storage.modifier.implements.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.separator.comma.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java + + a, +// ^ meta.constant.identifier.java entity.name.constant.java - meta.constant meta.constant +// ^ punctuation.separator.comma.java - meta.constant + + a(1, 2, 3), +// ^ meta.constant.identifier.java entity.name.constant.java - meta.constant meta.constant +// ^^^^^^^^^ meta.constant.arguments.java meta.group.java - meta.constant meta.constant +// ^ punctuation.section.group.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.separator.comma.java + + a +// ^ meta.constant.identifier.java entity.name.constant.java + (), +// ^ meta.constant.arguments.java meta.group.java punctuation.section.group.begin.java +// ^ meta.constant.arguments.java meta.group.java punctuation.section.group.end.java +// ^ punctuation.separator.comma.java + + a +// ^ meta.constant.identifier.java entity.name.constant.java + { +// ^^ meta.constant.java meta.block.java +// ^ punctuation.section.block.begin.java + }, +//^^^ meta.constant.java meta.block.java +// ^ punctuation.section.block.end.java +// ^ punctuation.separator.comma.java + + a { public void doSomething() { return; } }, +// ^^ meta.constant.identifier.java - meta.constant meta.constant +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.constant.java meta.block.java - meta.constant meta.constant +// ^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^^^^^^^^^^ meta.function.java meta.block.java +// ^ entity.name.constant.java +// ^ punctuation.section.block.begin.java +// ^^^^^^ storage.modifier.java +// ^^^^ meta.function.return-type.java +// ^^^^^^ storage.modifier.java +// ^^^^ storage.type.void.java +// ^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^^^^^ keyword.control.flow.return.java +// ^ punctuation.terminator.java +// ^ punctuation.section.block.end.java +// ^ punctuation.section.block.end.java +// ^ punctuation.separator.comma.java + + a ( 1 , 2 , 3 ) { public void doSomething() { return; } }, +// ^^ meta.constant.identifier.java - meta.constant meta.constant +// ^^^^^^^^^^^^^ meta.constant.arguments.java meta.group.java - meta.constant meta.constant +// ^ meta.constant.java - meta.constant meta.constant +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.constant.java meta.block.java - meta.constant meta.constant +// ^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^^^^^^^^^^ meta.function.java meta.block.java +// ^ entity.name.constant.java +// ^ punctuation.section.group.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^^^^^ storage.modifier.java +// ^^^^ storage.type.void.java +// ^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^^^^^ keyword.control.flow.return.java +// ^ punctuation.terminator.java +// ^ punctuation.section.block.end.java +// ^ punctuation.section.block.end.java +// ^ punctuation.separator.comma.java + + A, +// ^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.separator.comma.java + + A(1), +// ^ meta.constant.identifier.java entity.name.constant.java +// ^ meta.constant.arguments.java meta.group.java punctuation.section.group.begin.java +// ^ meta.constant.arguments.java meta.group.java meta.number.integer.decimal.java constant.numeric.value.java +// ^ meta.constant.arguments.java meta.group.java punctuation.section.group.end.java +// ^ punctuation.separator.comma.java + + A {}, +// ^^ meta.constant.identifier.java +// ^ entity.name.constant.java +// ^ meta.constant.java meta.block.java punctuation.section.block.begin.java +// ^ meta.constant.java meta.block.java punctuation.section.block.end.java +// ^ punctuation.separator.comma.java + + integerToken, +// ^^^^^^^^^^^^ meta.constant.identifier.java entity.name.constant.java +// ^ punctuation.separator.comma.java + + integerToken("integer literal"), +// ^^^^^^^^^^^^ meta.constant.identifier.java entity.name.constant.java +// ^^^^^^^^^^^^^^^^^^^ meta.constant.arguments.java meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^^ string.quoted.double.java +// ^ punctuation.section.group.end.java +// ^ punctuation.separator.comma.java + + integerToken {}; +// ^^^^^^^^^^^^ meta.constant.identifier.java entity.name.constant.java +// ^ meta.constant.identifier.java - constant +// ^ meta.constant.java meta.block.java punctuation.section.block.begin.java +// ^ meta.constant.java meta.block.java punctuation.section.block.end.java +// ^ punctuation.terminator.java + + int {} +// ^^^ storage.type.primitive.java + + const {} +// ^^^^^ invalid.illegal.keyword.java + + static {} +// ^^^^^^ storage.modifier.java + + String image = ""; +// ^^^^^^ storage.type.class.java +// ^^^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^^ string.quoted.double.java +// ^ punctuation.terminator.java + + TokenKind(String s) {} +// ^^^^^^^^^^^^^^^^^^^^^^ meta.enum.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^ meta.function.identifier.java +// ^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^ meta.function.java - meta.function meta.function +// ^^^^^^^^^ entity.name.function.constructor.java +// ^ punctuation.section.group.begin.java +// ^^^^^^ storage.type.class.java +// ^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + final int attribAfterConstructor; +// ^^^^^^ meta.field.modifier.java +// ^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +// ^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^^^^^^^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + public static void main(String[]a){} +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.enum.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^ meta.function.identifier.java +// ^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^ meta.function.java +// ^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^^ storage.type.void.java +// ^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^ storage.type.class.java +// ^^ storage.modifier.array.java +// ^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + final int attribAfterMember; +// ^^^^^^ meta.field.modifier.java +// ^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +// ^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + private class SubClass {} +// ^^^^^^^^^^^^^ meta.class.java +// ^^^^^^^^^^ meta.class.identifier.java +// ^^ meta.class.java meta.block.java +// ^^^^^^^ storage.modifier.java +// ^^^^^ keyword.declaration.class.java +// ^^^^^^^^ entity.name.class.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + private final int attribAfterClass; +// ^^^^^^^^^^^^^^ meta.field.modifier.java +// ^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +// ^^^^^^^ storage.modifier.java +// ^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^^^^^ variable.other.member.java +// ^ punctuation.terminator.java +} +//<- meta.enum.java meta.block.java punctuation.section.block.end.java + +@Anno // comment +// <- meta.enum.java meta.annotation.identifier.java meta.path.java punctuation.definition.annotation.java +. // comment +// <- meta.enum.java meta.annotation.identifier.java meta.path.java punctuation.accessor.dot.java +Anno // comment +// <- meta.annotation.identifier.java meta.path.java variable.annotation.java +( // comment +// <- meta.annotation.parameters.java meta.group.java punctuation.section.group.begin.java + par // comment +// ^^^ meta.enum.java meta.annotation.parameters.java meta.group.java variable.parameter.java + = // comment +// ^ meta.enum.java meta.annotation.parameters.java meta.group.java keyword.operator.assignment.java + 1 // comment +// ^ meta.enum.java meta.annotation.parameters.java meta.group.java meta.number.integer.decimal.java constant.numeric.value.java +) // comment +// <- meta.annotation.parameters.java meta.group.java punctuation.section.group.end.java +public // comment +//<- meta.enum.java storage.modifier.java +enum // comment +//<- meta.enum.java +TokenKind // comment +//<- meta.enum.identifier.java entity.name.enum.java +extends // comment +//<- meta.enum.extends.java invalid.illegal.unexpected-keyword.java +MyEnum, // comment +//<- meta.enum.extends.java entity.other.inherited-class.java +FooBaz // comment +//<- meta.enum.extends.java entity.other.inherited-class.java +implements // comment +//<- meta.enum.implements.java storage.modifier.implements.java +Foo, // comment +//<- meta.enum.implements.java entity.other.inherited-class.java +Bar // comment +//<- meta.enum.implements.java entity.other.inherited-class.java +{ +//<- meta.enum.java meta.block.java punctuation.section.block.begin.java +} +//<- meta.enum.java meta.block.java punctuation.section.block.end.java + + +/****************************************************************************** + * Interface Declaration Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-9.html#jls-9.1 + *****************************************************************************/ + +interface$ ; +// <- meta.variable.identifier.java variable.other.java +//^^^^^^^^ meta.variable.identifier.java variable.other.java + +$interface ; +// <- meta.variable.identifier.java variable.other.java +//^^^^^^^^ meta.variable.identifier.java variable.other.java + +interface +//<- meta.interface.java keyword.declaration.interface.java +//^^^^^^^ meta.interface.java keyword.declaration.interface.java +// ^ meta.interface.identifier.java + +interface TestIntf +//<- meta.interface.java keyword.declaration.interface.java +//^^^^^^^ meta.interface.java +// ^^^^^^^^^^ meta.interface.identifier.java +//^^^^^^^ keyword.declaration.interface.java +// ^^^^^^^^ entity.name.interface.java + +interface TestIntf extends +//<- meta.interface.java keyword.declaration.interface.java +//^^^^^^^ meta.interface.java +// ^^^^^^^^^^ meta.interface.identifier.java +// ^^^^^^^^ meta.interface.extends.java +//^^^^^^^ keyword.declaration.interface.java +// ^^^^^^^^ entity.name.interface.java +// ^^^^^^^ storage.modifier.extends.java + +interface TestIntf extends A, BB {} +//<- meta.interface.java keyword.declaration.interface.java +//^^^^^^^ meta.interface.java +// ^^^^^^^^^^ meta.interface.identifier.java +// ^^^^^^^^^^^^^^ meta.interface.extends.java +// ^^ meta.interface.java meta.block.java +//^^^^^^^ keyword.declaration.interface.java +// ^^^^^^^^ entity.name.interface.java +// ^^^^^^^ storage.modifier.extends.java +// ^ entity.other.inherited-class.java +// ^ punctuation.separator.comma.java +// ^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +public interface /**/ TestIntf /**/ extends /**/ A /**/, /**/ BB /**/ {} +//<- meta.interface.java storage.modifier.java +//^^^^^^^^^^^^^^ meta.interface.java +// ^^^^^^^^^^^^^^^ meta.interface.identifier.java - meta.generic +// ^^^^^^^^ meta.interface.identifier.java meta.generic.declaration.java +// ^^^^^^ meta.interface.identifier.java - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.extends.java +// ^^ meta.interface.java meta.block.java +//^^^^ storage.modifier.java +// ^^^^^^^^^ keyword.declaration.interface.java +// ^^^^ comment.block.empty.java +// ^^^^^^^^ entity.name.interface.java +// ^ punctuation.section.generic.begin.java +// ^^ variable.parameter.type.java +// ^ punctuation.separator.comma.java +// ^^ variable.parameter.type.java +// ^ punctuation.section.generic.end.java +// ^^^^ comment.block.empty.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^ comment.block.empty.java +// ^ entity.other.inherited-class.java +// ^^^^ comment.block.empty.java +// ^ punctuation.separator.comma.java +// ^^^^ comment.block.empty.java +// ^^ entity.other.inherited-class.java +// ^^^^ comment.block.empty.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +public abstract sealed interface SealedInterfaceTest permits +// <- meta.interface.java storage.modifier.java +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.java +// ^^^^^^^^^^^^^^^^^^^^ meta.interface.identifier.java +// ^^^^^^^^ meta.interface.permits.java +//^^^^ storage.modifier.java +// ^^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^^^^^^^ keyword.declaration.interface.java +// ^^^^^^^^^^^^^^^^^^^ entity.name.interface.java +// ^^^^^^^ storage.modifier.permits.java + +public abstract sealed interface SealedInterfaceTest permits Foo, bar.Baz {} +// <- meta.interface.java storage.modifier.java +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.java +// ^^^^^^^^^^^^^^^^^^^^^ meta.interface.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^ meta.interface.permits.java +// ^^ meta.interface.java meta.block.java +//^^^^ storage.modifier.java +// ^^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^^^^^^^ keyword.declaration.interface.java +// ^^^^^^^^^^^^^^^^^^^ entity.name.interface.java +// ^^^^^^^ storage.modifier.permits.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.separator.comma.java +// ^^^^^^^ meta.path.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +@Anno // comment +//<- meta.interface.java meta.annotation.identifier.java punctuation.definition.annotation.java +public // comment +//<- meta.interface.java storage.modifier.java +interface // comment +//<- meta.interface.java +TestIntf // comment +//<- meta.interface.identifier.java entity.name.interface.java + +//<- meta.interface.identifier.java meta.generic.declaration.java +extends // comment +//<- meta.interface.extends.java storage.modifier.extends.java +MyEnum, // comment +//<- meta.interface.extends.java entity.other.inherited-class.java +FooBaz // comment +//<- meta.interface.extends.java entity.other.inherited-class.java +implements // comment +//<- meta.interface.implements.java invalid.illegal.unexpected-keyword.java +Foo, // comment +//<- meta.interface.implements.java entity.other.inherited-class.java +Bar // comment +//<- meta.interface.implements.java entity.other.inherited-class.java +{ +//<- meta.interface.java meta.block.java punctuation.section.block.begin.java +} +//<- meta.interface.java meta.block.java punctuation.section.block.end.java + + +/****************************************************************************** + * Annotation Declaration Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-9.html#jls-9.6 + *****************************************************************************/ + +@interface$ ; +//<- meta.annotation.identifier.java punctuation.definition.annotation.java +//^^^^^^^^^ meta.annotation.identifier.java variable.annotation.java + +@$interface ; +//<- meta.annotation.identifier.java punctuation.definition.annotation.java +//^^^^^^^^^ meta.annotation.identifier.java variable.annotation.java + +@interface +//<- meta.interface.java keyword.declaration.interface.java +//^^^^^^^^ meta.interface.java keyword.declaration.interface.java +// ^ meta.interface.identifier.java + +@interface AnnotationType +//<- meta.interface.java keyword.declaration.interface.java +//^^^^^^^^ meta.interface.java +// ^^^^^^^^^^^^^^^^ meta.interface.identifier.java +//^^^^^^^^ keyword.declaration.interface.java +// ^^^^^^^^^^^^^^ entity.name.interface.java + +// Note: The extends is actually not allowed here, but the syntax definition does +// not yet distiguish between interface types and annotation types +@interface AnnotationType extends +//<- meta.interface.java keyword.declaration.interface.java +//^^^^^^^^ meta.interface.java +// ^^^^^^^^^^^^^^^^ meta.interface.identifier.java +// ^^^^^^^^ meta.interface.extends.java +//^^^^^^^^ keyword.declaration.interface.java +// ^^^^^^^^^^^^^^ entity.name.interface.java +// ^^^^^^^ storage.modifier.extends.java + +@interface AnnotationType { +//<- meta.interface.java keyword.declaration.interface.java +//^^^^^^^^ meta.interface.java +// ^^^^^^^^^^^^^^^^ meta.interface.identifier.java +// ^^ meta.interface.java meta.block.java +//^^^^^^^^ keyword.declaration.interface.java +// ^^^^^^^^^^^^^^ entity.name.interface.java +// ^ punctuation.section.block.begin.java + + int numericValue() default 42; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.java meta.block.java meta.function - meta.function meta.function +//^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^^^^^^^^^ meta.function.default.java +// ^ - meta.function +// ^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^^ keyword.declaration.default.java +// ^^ constant.numeric + + boolean booleanValue() default true; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^^^^^^^^^^^ meta.function.default.java +// ^ - meta.function +// ^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^^ keyword.declaration.default.java +// ^^^^ constant.language + + char charValue() default 'S'; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.java meta.block.java meta.function - meta.function meta.function +//^^^^^ meta.function.return-type.java +// ^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^^^^^^^^^^ meta.function.default.java +// ^ - meta.function +// ^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^^ keyword.declaration.default.java +// ^^^ string.quoted.single.java + + String value() default "Default value"; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^ meta.function.return-type.java +// ^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.function.default.java +// ^ - meta.function +// ^^^^^^^ keyword.declaration.default.java +// ^^^^^^^^^^^^^^^ string.quoted.double.java + + Class classValue() default String.class; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^ meta.function.return-type.java +// ^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^^^^^^^^^^^^^^^^^^^ meta.function.default.java +// ^ - meta.function +// ^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^^ keyword.declaration.default.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java - storage.type.java + + String[] arrayValue()[] default {"Foo", "Bar"}; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.interface.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^ meta.function.return-type.java +// ^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^^^ meta.function.java +// ^^^^^^^^ meta.function.default.java - meta.braces +// ^^^^^^^^^^^^^^ meta.function.default.java meta.braces.java +// ^ - meta.function +// ^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^ storage.modifier.array.java +// ^^^^^^^ keyword.declaration.default.java +// ^ punctuation.section.braces.begin.java +// ^^^^^ string.quoted.double.java +// ^ punctuation.separator.comma.java +// ^^^^^ string.quoted.double.java +// ^ punctuation.section.braces.end.java +} + +/****************************************************************************** + * Record Class Tests + * https://docs.oracle.com/javase/specs/jls/se16/html/jls-8.html#jls-8.10 + *****************************************************************************/ + +record +// <- meta.class.java keyword.declaration.record.java +//^^^^ meta.class.java keyword.declaration.record.java +// ^ meta.class.identifier.java + +record RecordTest +// <- meta.class.java keyword.declaration.record.java +//^^^^ meta.class.java keyword.declaration.record.java +// ^^^^^^^^^^^^ meta.class.identifier.java +// ^^^^^^^^^^ entity.name.class.java + +record RecordTest<> +// <- meta.class.java keyword.declaration.record.java +//^^^^ meta.class.java keyword.declaration.record.java +// ^^^^^^^^^^^ meta.class.identifier.java - meta.generic +// ^^ meta.class.identifier.java meta.generic.declaration.java +// ^ meta.class.identifier.java - meta.generic +// ^^^^^^^^^^ entity.name.class.java +// ^ punctuation.section.generic.begin.java +// ^ punctuation.section.generic.end.java + +record RecordTest +// <- meta.class.java keyword.declaration.record.java +//^^^^ meta.class.java keyword.declaration.record.java +// ^^^^^^^^^^^ meta.class.identifier.java - meta.generic +// ^^^ meta.class.identifier.java meta.generic.declaration.java +// ^ meta.class.identifier.java - meta.generic +// ^^^^^^^^^^ entity.name.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.parameter.type.java +// ^ punctuation.section.generic.end.java + +record RecordTest( { } +// <- meta.class.java keyword.declaration.record.java +//^^^^ meta.class.java keyword.declaration.record.java +// ^^^^^^^^^^^ meta.class.identifier.java +// ^^ meta.class.parameters.java meta.group.java +// ^^^^ meta.class.java meta.block.java +// ^^^^^^^^^^ entity.name.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +record RecordTest<>( { } +// <- meta.class.java keyword.declaration.record.java +//^^^^ meta.class.java keyword.declaration.record.java +// ^^^^^^^^^^^ meta.class.identifier.java - meta.generic +// ^^ meta.class.identifier.java meta.generic.declaration.java +// ^^ meta.class.parameters.java meta.group.java +// ^^^^ meta.class.java meta.block.java +// ^^^^^^^^^^ entity.name.class.java +// ^ punctuation.section.generic.begin.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +record RecordTest(int x, int y) { } +// <- meta.class.java keyword.declaration.record.java +//^^^^ meta.class.java keyword.declaration.record.java +// ^^^^^^^^^^^ meta.class.identifier.java +// ^^^^^^^^^^^^^^ meta.class.parameters.java meta.group.java +// ^ meta.class.java +// ^^^ meta.class.java meta.block.java +// ^^^^^^^^^^ entity.name.class.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +record RecordTest(int x, @notnull foo bar) implements Foo, Bar { } +// <- meta.class.java keyword.declaration.record.java +//^^^^ meta.class.java keyword.declaration.record.java +// ^^^^^^^^^^^^^^ meta.class.identifier.java +// ^^^ meta.generic.declaration.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.parameters.java meta.group.java +// ^^^^^^^^ meta.annotation.identifier.java +// ^ meta.class.java +// ^^^^^^^^^^^^^^^^^^^^ meta.class.implements.java +// ^^^ meta.class.java meta.block.java +// ^^^^^^^^^^ entity.name.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.parameter.type.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^ punctuation.definition.annotation.java +// ^^^^^^^ variable.annotation.java +// ^^^ storage.type.class.java +// ^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^^^^^^^^^^ storage.modifier.implements.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.separator.comma.java +// ^^^ entity.other.inherited-class.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + +record CompactConstructorTests(int foo) { + CompactConstructorTests { +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.class.java meta.block.java meta.function.java meta.block.java +// ^ punctuation.section.block.begin.java + foo = 20; +// ^^^^^^^^^^^ meta.function.java meta.block.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^ constant.numeric.value.java +// ^ punctuation.terminator.java + } +// ^ meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java +} +// <- meta.class.java meta.block.java punctuation.section.block.end.java + +/****************************************************************************** + * Field Declaration Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4 + *****************************************************************************/ + +class FieldDeclarationTests { + + const int bar; // this comment() is recognized as code +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^ - meta.field +// ^^^^ meta.field.type.java +// ^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^^ invalid.illegal.keyword.java +// ^^^ storage.type.primitive.java +// ^^^ variable.other.member.java +// ^ punctuation.terminator.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.line +// ^^ punctuation.definition.comment.java + + int +//^^^^ meta.field.type.java - meta.field meta.field +//^^^ storage.type.primitive.java + + int foo +//^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java +// ^^^^ meta.field.identifier.java +//^^^ storage.type.primitive.java +// ^^^ variable.other.member.java + + int foo = +//^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java +// ^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^ meta.field.value.java +//^^^ storage.type.primitive.java +// ^^^ variable.other.member.java +// ^ keyword.operator.assignment.java + + int foo = 0 +//^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java +// ^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^ meta.field.value.java +//^^^ storage.type.primitive.java +// ^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java + + int foo = 0 , +//^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java +// ^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^ meta.field.value.java +// ^ meta.field.java +// ^ meta.field.identifier.java +//^^^ storage.type.primitive.java +// ^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java + + int foo = 0 , bar ; +//^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java +// ^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^ meta.field.value.java +// ^ meta.field.java +// ^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^ storage.type.primitive.java +// ^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.member.java +// ^ punctuation.terminator.java + + int = +//^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java +// ^ meta.field.java +// ^ meta.field.value.java +//^^^ storage.type.primitive.java +// ^ keyword.operator.assignment.java + + public +//^^^^^^^ meta.field.modifier.java +//^^^^^^ storage.modifier.java +// ^ - storage + int foo , bar +//<- meta.field.modifier.java - meta.field meta.field - storage +//^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java +// ^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^ meta.field.identifier.java +//^^^ storage.type.primitive.java +// ^^^ variable.other.member.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.member.java + , baz +//^^^^^^^^ - meta.field meta.field +//^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^ meta.field.identifier.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.member.java + = 10 , +//^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^ meta.field.value.java +// ^ meta.field.java +// ^ keyword.operator.assignment.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java + , = 20 +//^^^^^^^^^ - meta.field meta.field +//^^ meta.field.identifier.java +// ^ meta.field.java +// ^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^ meta.field.value.java +// ^ punctuation.separator.comma.java +// ^ keyword.operator.assignment.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java + , , ; +//^^^^^^ - meta.field meta.field +//^^ meta.field.value.java +// ^ meta.field.java punctuation.separator.comma.java +// ^ meta.field.identifier.java +// ^ meta.field.java punctuation.separator.comma.java +// ^ meta.field.identifier.java +// ^ punctuation.terminator.java - meta.field + + int[] +//^^^^^^ - meta.field meta.field +//^^^^^^ meta.field.type.java +//^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java + + int [] +//^^^^^^ - meta.field meta.field +//^^^^^^ meta.field.type.java +//^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java + + int[] foo +//^^^^^^^^^ - meta.field meta.field +//^^^^^^ meta.field.type.java +// ^^^ meta.field.identifier.java +//^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^^^ variable.other.member.java + + int foo[], [] +//^^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java +// ^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^ meta.field.identifier.java +//^^^ storage.type.primitive.java +// ^^^ variable.other.member.java +// ^^ storage.modifier.array.java +// ^ punctuation.separator.comma.java +// ^^ storage.modifier.array.java + + public protected private static final transient volatile int foo +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.modifier.java +// ^^^^ meta.field.type.java +// ^^^^ meta.field.identifier.java +//^^^^^^ storage.modifier.java +// ^ - storage +// ^^^^^^^^^ storage.modifier.java +// ^ - storage +// ^^^^^^^ storage.modifier.java +// ^ - storage +// ^^^^^^ storage.modifier.java +// ^ - storage +// ^^^^^ storage.modifier.java +// ^ - storage +// ^^^^^^^^^ storage.modifier.java +// ^ - storage +// ^^^^^^^^ storage.modifier.java +// ^ - storage +// ^^^ storage.type.primitive.java +// ^ - storage - variable +// ^^^ variable.other.member.java +// ^ - variable + + abstract native synchronized strictfp default int foo.bar +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.modifier.java - storage +// ^^^^ meta.field.type.java +// ^^^^^^^^ meta.field.identifier.java +//^^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^ - invalid +// ^^^^^^ invalid.illegal.unexpected-keyword.java +// ^ - invalid +// ^^^^^^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^ - invalid +// ^^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^ - invalid +// ^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^ - invalid +// ^^^ storage.type.primitive.java +// ^ - storage - variable +// ^^^ variable.other.member.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^ invalid.illegal.unexpected-member.java + + private String +//^^^^^^^^ meta.field.modifier.java +// ^^^^^^^ meta.field.type.java +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.type.class.java + + private string +//^^^^^^^^ meta.field.modifier.java +// ^^^^^^^ meta.field.type.java +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.type.class.java + + private String memberString1 = "Hello"; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^ meta.field.modifier.java +// ^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^ meta.field.value.java +// ^ - meta.field +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.type.class.java +// ^^^^^^^^^^^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^^^^^^^ string.quoted.double.java +// ^ punctuation.terminator.java + + private String memberString2 = @Anno new String("Hello"); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^ meta.field.modifier.java +// ^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^ meta.field.value.java - meta.instantiation - meta.annotation +// ^^^^^ meta.field.value.java meta.annotation.identifier.java +// ^ meta.field.value.java - meta.annotation - meta.instantiation +// ^^^^^^^^^^^^^^^^^^^ meta.field.value.java meta.instantiation.java - meta.annotation +// ^ - meta.field +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.type.class.java +// ^^^^^^^^^^^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^ string.quoted.double.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + private String memberString3 = String.valueOf("Hello"); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^ meta.field.modifier.java +// ^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.field.value.java +// ^^^^^^^ meta.function-call.identifier.java +// ^^^^^^^^^ meta.function-call.arguments.java meta.group.java +// ^ - meta.field +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.type.class.java +// ^^^^^^^^^^^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^ string.quoted.double.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + private int memberLpos = memberString3.indexOf("l"); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^ meta.field.modifier.java +// ^^^^ meta.field.type.java +// ^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.field.value.java +// ^^^^^^^ meta.function-call.identifier.java +// ^^^^^ meta.function-call.arguments.java meta.group.java +// ^ - meta.field +//^^^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^^^^^^^^^^^^^ variable.other.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^ string.quoted.double.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + public var MY_CONST = 0x4002; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^ meta.field.modifier.java +// ^^^^ meta.field.type.java +// ^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^ meta.field.value.java +// ^ - meta.field +//^^^^^^ storage.modifier.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^^^^^^^^ entity.name.constant.java +// ^ keyword.operator.assignment.java +// ^^^^^^ constant.numeric +// ^ punctuation.terminator.java + + private static final string DEFAULT_IDEMPOTENCY_KEY = "44493"; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^^^^^^^ meta.field.modifier.java +// ^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^ meta.field.value.java +// ^ - meta.field +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^^^ storage.modifier.java +// ^^^^^^ storage.type.class.java +// ^^^^^^^^^^^^^^^^^^^^^^^ entity.name.constant.java +// ^ keyword.operator.assignment.java +// ^^^^^^^ string.quoted.double.java +// ^ punctuation.terminator.java +// + + public static +//^^^^^^^^^^^^^^ meta.field.modifier.java +//^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java + final MyObject +//^^^^^^ meta.field.modifier.java +// ^^^^^^^^^ meta.field.type.java +//^^^^^ storage.modifier.java +// ^^^^^^^^ storage.type.class.java + MY_CONST = new MyObject(), +//^^ meta.field.type.java +// ^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^^^^^^^^ meta.field.value.java +// ^ meta.field.java +// ^^^^^^^^ entity.name.constant.java +// ^ keyword.operator.assignment.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.separator.comma.java + + _MY_ANOTHER_CONST = new MyObject(); +//^^^^^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^^^^^^^^ meta.field.value.java +// ^ - meta.field +// ^^^^^^^^^^^^^^^^^ entity.name.constant +// ^ keyword.operator.assignment.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + private MyObject otherObject = MY_CONST; +// ^^^^^^^^ constant.other.java +// ^ punctuation.terminator.java + + private MyObject otherObject = SOME_CONST.FOO; +// ^^^^^^^^^^ constant.other.java +// ^ punctuation.accessor.dot.java +// ^^^ constant.other.java +// ^ punctuation.terminator.java + + private MyObject otherObject = SOME_CONST.get(); +// ^^^^^^^^^^ constant.other.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + private a.b.myerror error = a.b.ErrorCode.COMMUNICATION_ERROR; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^ meta.field.modifier.java +// ^^^^^^^^^^^^ meta.field.type.java +// ^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.value.java +// ^ - meta.field +//^^^^^^^^ - meta.path +// ^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^ - meta.path +// ^^^^^^^^^^^^^ meta.path.java +//^^^^^^^ storage.modifier.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ storage.type.class.java +// ^^^^^ variable.other.member.java +// ^ keyword.operator.assignment.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^^^^^^^^^ constant.other.java +// ^ punctuation.terminator.java + + private a /**/ . /**/ b /**/ . /**/ myerror /**/ error /**/ = /**/ a.b.ErrorCode.COMMUNICATION_ERROR; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^ meta.field.modifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.value.java +// ^ - meta.field +//^^^^^^^^ - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ - meta.path +// ^^^^^^^^^^^^^ meta.path.java +//^^^^^^^ storage.modifier.java +// ^ variable.namespace.java +// ^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^ punctuation.accessor.dot.java +// ^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^ variable.namespace.java +// ^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^ punctuation.accessor.dot.java +// ^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^^^^^^^ storage.type.class.java +// ^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^^^^^ variable.other.member.java +// ^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^ keyword.operator.assignment.java +// ^^^^ comment.block.empty.java punctuation.definition.comment.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^^^^^^^^^ constant.other.java +// ^ punctuation.terminator.java + + private static final UUID SECURE_ID = UUID.randomUUID(); +// ^^^^ storage.type.class.java +// ^^^^^^^^^ entity.name.constant +// ^^^^ storage.type.class.java +// ^^^^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + private URI uri = new URI(); +// ^^^ storage.type.class.java +// ^^^ variable.other.member.java +// ^^^ storage.type.class.java + + private URI URI2 = new URI(); +// ^^^ storage.type.class.java +// ^^^^ entity.name.constant.java +// ^^^ storage.type.class.java + + byte[] byteArray; +//^^^^^^^ meta.field.type.java +// ^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^^^^^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + byte byteArray2[] = {1, 2}; +//^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^ meta.field.value.java +// ^ - meta.field +//^^^^ storage.type.primitive.java +// ^^^^^^^^^^ variable.other.member.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.assignment.java +// ^ punctuation.section.braces.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.terminator.java + + byte byteArray3[] = condition ? {1, 2} : {4, 5}; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.value.java +// ^ - meta.field +//^^^^ storage.type.primitive.java +// ^^^^^^^^^^ variable.other.member.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.assignment.java +// ^^^^^^^^^ variable.other.java +// ^ keyword.operator.ternary.java +// ^ punctuation.section.braces.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ keyword.operator.ternary.java +// ^ punctuation.section.braces.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.terminator.java + + byte byteArray4[] = condition ? fun() ? {1, 2} : {3, 0} : {4, 5}; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^ meta.field.identifier.java +// ^ meta.field.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.value.java +// ^ - meta.field +//^^^^ storage.type.primitive.java +// ^^^^^^^^^^ variable.other.member.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.assignment.java +// ^^^^^^^^^ variable.other.java +// ^ keyword.operator.ternary.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ keyword.operator.ternary.java +// ^ punctuation.section.braces.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ keyword.operator.ternary.java +// ^ punctuation.section.braces.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ keyword.operator.ternary.java +// ^ punctuation.section.braces.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.terminator.java + + String[][] doubleStringArray; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^^^ storage.type.class.java +// ^^^^ storage.modifier.array.java +// ^^^^^^^^^^^^^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + @NotNull final String @Anno [ ] @Anno [ ] doubleStringArray @Anno [ ] [ ]; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^ meta.field.modifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^ - meta.annotation +// ^^^^^ meta.annotation.identifier.java +// ^^^^^ - meta.annotation +// ^^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^ - meta.annotation +// ^^^^^ meta.annotation.identifier.java +// ^^^^^^^^^ - meta.annotation +// ^^^^^ storage.modifier.java +// ^^^^^^ storage.type.class.java +// ^^^ storage.modifier.array.java +// ^^^ storage.modifier.array.java +// ^^^^^^^^^^^^^^^^^ variable.other.member.java +// ^^^ storage.modifier.array.java +// ^^^ storage.modifier.array.java +// ^ punctuation.terminator.java + + qualified.String[][] doubleStringArray; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^^^^^^^^^^^^^^^ - meta.path +//^^^^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^ storage.type.class.java +// ^^^^ storage.modifier.array.java +// ^^^^^^^^^^^^^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + fully.qualified.string[][] doubleStringArray; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^^^^^^^^^^^^^^^ - meta.path +//^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^ storage.type.class.java +// ^^^^ storage.modifier.array.java +// ^^^^^^^^^^^^^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + @anno /**/ fully // comment +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^ meta.field.modifier.java meta.annotation.identifier.java +// ^^^^^^ meta.field.modifier.java - meta.annotation - meta.pth +// ^^^^^^^^^^^^^^^^^ meta.field.type.java meta.path.java +//^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^ comment.block.empty.java +// ^^^^^ variable.namespace.java +// ^^^^^^^^^^^ comment.line.double-slash.java + . @anno qualified//comment +//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.type.java meta.path.java - meta.field meta.field +// ^^^^^ meta.annotation.identifier.java +//^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^^^ variable.namespace.java +// ^^^^^^^^^^ comment.line.double-slash.java + /**/ . /**/ +//^^^^^^^^^^^^ meta.field.type.java meta.path.java +//^^^^ comment.block.empty.java +// ^ punctuation.accessor.dot.java +// ^^^^ comment.block.empty.java + @anno /**/ object @anno() [] +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^^^ meta.field.type.java meta.path.java +// ^^^^^^^^^^^^ meta.field.type.java - meta.path +//^^^^^ meta.annotation.identifier.java +// ^^^^^ meta.annotation.identifier.java +// ^^ meta.annotation.parameters.java meta.group.java +//^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^ comment.block.empty.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^ storage.modifier.array.java + + /**/ @anno /**/ [] /**/ doubleObjectArray; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.type.java - meta.path +// ^^^^^^^^^^^^^^^^^ meta.field.identifier.java - meta.path +// ^ - meta.field +//^^^^ comment.block.empty.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^ comment.block.empty.java +// ^^ storage.modifier.array.java +// ^^^^ comment.block.empty.java +// ^^^^^^^^^^^^^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + List field; +//^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java - meta.generic +// ^^^^^ meta.field.type.java meta.generic.java +// ^ meta.field.type.java - meta.generic +// ^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.section.generic.end.java +// ^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + list field; +//^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java - meta.generic +// ^^^^^ meta.field.type.java meta.generic.java +// ^ meta.field.type.java - meta.generic +// ^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.section.generic.end.java +// ^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + List field; +//^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java - meta.generic +// ^^^^^^^^ meta.field.type.java meta.generic.java +// ^ meta.field.type.java - meta.generic +// ^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + list field; +//^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^ meta.field.type.java - meta.generic +// ^^^^^^^^ meta.field.type.java meta.generic.java +// ^ meta.field.type.java - meta.generic +// ^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + java.base.List field; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^ meta.field.type.java meta.path.java - meta.generic +// ^ meta.field.type.java meta.path.java meta.generic.java - meta.path meta.path +// ^^^^^^^^^^^^ meta.field.type.java meta.path.java meta.generic.java meta.path.java +// ^ meta.field.type.java meta.path.java meta.generic.java - meta.path meta.path +// ^ meta.field.type.java - meta.path.java - meta.generic +// ^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + java.base.list field; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^ meta.field.type.java meta.path.java - meta.generic +// ^ meta.field.type.java meta.path.java meta.generic.java - meta.path meta.path +// ^^^^^^^^^^^^ meta.field.type.java meta.path.java meta.generic.java meta.path.java +// ^ meta.field.type.java meta.path.java meta.generic.java - meta.path meta.path +// ^ meta.field.type.java - meta.path.java - meta.generic +// ^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + java.tmpl<>.list field; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^ meta.field.type.java meta.path.java - meta.generic +// ^^ meta.field.type.java meta.path.java meta.generic.java +// ^^^^^ meta.field.type.java meta.path.java - meta.generic +// ^ meta.field.type.java meta.path.java meta.generic.java - meta.path meta.path +// ^^^^^^^^^^^^ meta.field.type.java meta.path.java meta.generic.java meta.path.java +// ^ meta.field.type.java meta.path.java meta.generic.java - meta.path meta.path +// ^ meta.field.type.java - meta.path.java - meta.generic +// ^^^^^ meta.field.identifier.java +// ^ - meta.field +//^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ storage.type.class.java +// ^^ punctuation.section.generic.diamond.java +// ^ punctuation.accessor.dot.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^^ variable.other.member.java +// ^ punctuation.terminator.java + + private MyGenric, and.fully.Qualified, +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^ meta.field.modifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.type.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.generic.java - meta.generic meta.generic +// ^^^^^^^^^ meta.generic.java meta.generic.java +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.generic.java - meta.generic meta.generic +// ^^^^^^^^^^^^^^^^^^^ meta.path.java + and.fully.Qualified> myVariable; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.field meta.field +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.field.type.java +//^^^^^^^^^^^^^^^^^^^^^^^ meta.generic.java - meta.generic meta.generic +// ^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^ meta.generic.java meta.generic.java +// ^ meta.generic.java - meta.generic meta.generic +// ^ - meta.generic +// ^^^^^^^^^^ meta.field.identifier.java +// ^ - meta.field +} + + +/****************************************************************************** + * Global Method Declaration Tests + * Global methods are not valid in Java, but are supported to maintain + * syntax highlighting in JSP or incomplete code. + * + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4 + *****************************************************************************/ + +void globalMethodDeclarationTests() {} +// <- meta.function.return-type.java storage.type.void.java +//^^^ meta.function.return-type.java +//^^ storage.type.void.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.identifier.java entity.name.function.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java - meta.group - meta.block +// ^^ meta.function.java meta.block.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// + +int globalMethodDeclarationTests() {} +// <- meta.function.return-type.java storage.type.primitive.java +//^^ meta.function.return-type.java +//^ storage.type.primitive.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.identifier.java entity.name.function.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java - meta.group - meta.block +// ^^ meta.function.java meta.block.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// + + +/****************************************************************************** + * Method Declaration Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4 + *****************************************************************************/ + +class MethodDelcarationTests { + + void +//^^^^^ meta.function.return-type.java +//^^^^ storage.type.void.java + + void method +//^^^^^ meta.function.return-type.java +// ^^^^^^^ meta.function.identifier.java +//^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java + + void method( ; +//^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^ meta.function.return-type.java +// ^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ - meta.function +//^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.terminator.java + + void method() +//^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^ meta.function.return-type.java +// ^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +//^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java + + void method(foo bar ; +//^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^ meta.function.return-type.java +// ^^^^^^ meta.function.identifier.java +// ^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^ - meta.function +//^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.class.java +// ^^^ variable.parameter.java +// ^ punctuation.terminator.java + + static void method() +//^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +//^^^^^^ storage.modifier.java +// ^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java + + native strictfp transient volatile void method() {private} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^^^^^^^^ meta.function.java meta.block.java +//^^^^^^ storage.modifier.java +// ^ - invalid +// ^^^^^^^^ storage.modifier.java +// ^ - invalid +// ^^^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^ - invalid +// ^^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^ - invalid - storage +// ^^^^ storage.type.void.java +// ^ - entity - storage +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^^^^^^ storage.modifier.java +// ^ punctuation.section.block.end.java + + void à ( ) {} +//^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^ meta.function.return-type.java +// ^^ meta.function.identifier.java +// ^^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^ meta.function.java meta.block.java +//^^^^ storage.type.void.java +// ^ entity.name.function +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + void bar$ () {} +//^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^ meta.function.return-type.java +// ^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^ meta.function.java meta.block.java +//^^^^ storage.type.void.java +// ^^^^ entity.name.function +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + // It looks like a function definition then highlight it as such, even in function bodies. + int localMethodTest() { boolean bar() { void baz(); } } +//^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^ meta.function.java meta.block.java +// ^^^^^^^^ meta.function.java meta.block.java meta.function.return-type.java +// ^^^ meta.function.java meta.block.java meta.function.identifier.java +// ^^ meta.function.java meta.block.java meta.function.parameters.java meta.group.java +// ^ meta.function.java meta.block.java meta.function.java +// ^^^^^^^^^^^^^^^ meta.function.java meta.block.java meta.function.java meta.block.java +// ^^ meta.function.java meta.block.java +//^^^ storage.type.primitive.java +// ^^^^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^^^^^^ storage.type.primitive.java +// ^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^^^ storage.type.void.java +// ^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java +// ^ punctuation.section.block.end.java +// ^ punctuation.section.block.end.java + + public +//^^^^^^^ meta.function.modifier.java - meta.function meta.function +//^^^^^^ storage.modifier.java + void +//^^^^^ meta.function.return-type.java - meta.function meta.function +//^^^^ storage.type.void.java + methodNameOnDifferentLine(); +//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.identifier.java entity.name.function.java + + abstract void myAbstractMethod (With foo); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^^^^^^^^^^^^ meta.generic.java +// ^ - meta.function +//^^^^^^^^ storage.modifier.java +// ^^^^ storage.type.void.java +// ^^^^^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + private Long myOtherAbstractMethod(@WithAnnotation Blah blah); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^^^^^^^^^^^^^ meta.annotation.identifier.java +// ^ - meta.function +// ^^^^^^^^^^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.definition.annotation.java +// ^^^^^^^^^^^^^^ variable.annotation.java +// ^^^^ storage.type.class.java +// ^^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + protected static void methodList(List args) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^^^^^ meta.function.identifier.java - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java - meta.function meta.function +// ^ meta.function.java - meta.function meta.function +// ^^ meta.function.java - meta.function meta.function +//^^^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^^ storage.type +// ^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + public MyGeneric ABSTRACTMETHOD(Foo bar); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^ meta.function.modifier.java +// ^^^^^^^^^ meta.function.return-type.java - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.return-type.java meta.generic.java +// ^ meta.function.return-type.java - meta.generic +// ^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^^^ meta.function.parameters.java meta.group.java - meta.generic +// ^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java meta.generic.java +// ^^^^^ meta.function.parameters.java meta.group.java - meta.generic +//^^^^^^ storage.modifier.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^^^^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + private static int methodThrows() throws MyException { +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java +// ^ meta.function.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.throws.java +// ^^^^^ meta.generic.java +// ^^ meta.function.java +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^ keyword.declaration.throws.java +// ^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.block.begin.java + throw +//^^^^^^^^ meta.function.java meta.block.java +// ^^^^^^ meta.statement.flow.throw.java +// ^^^^^ keyword.control.flow.throw.java + new +//^^^^^^^^^^ meta.function.java meta.block.java +// ^ meta.statement.flow.throw.java - meta.instantiation +// ^^^^ meta.statement.flow.throw.java meta.instantiation.java +// ^^^ keyword.other.storage.new.java + MyException +//^^^^^^^^^^^^^^^^^^ meta.function.java meta.block.java +// ^^^^^^^^^^^^^ meta.statement.flow.throw.java meta.instantiation.java +// ^^^^^^^^^^^ storage.type.class.java + ("hello (world)"); +//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.java meta.block.java +// ^^^^^^^^^^^^^^^^^ meta.statement.flow.throw.java meta.instantiation.java meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^ string.quoted.double.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + } +//^ meta.function.java meta.block.java punctuation.section.block.end.java +// ^ - meta.function + + private static int methodthrows() throws int {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java +// ^ meta.function.java +// ^^^^^^^^^^^ meta.function.throws.java +// ^^ meta.function.java +// ^ - meta.function +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^ keyword.declaration.throws.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + private static int methodthrows() throws array[] {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java +// ^ meta.function.java +// ^^^^^^^^^^^^^^^ meta.function.throws.java +// ^^ meta.function.java +// ^ - meta.function +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^ keyword.declaration.throws.java +// ^^^^^ storage.type.class.java +// ^^ invalid.illegal.unexpected-modifier.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + private static int methodthrows() throws myexception {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java +// ^ meta.function.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.throws.java +// ^^^^^ meta.generic.java +// ^^ meta.function.java +// ^ - meta.function +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^ keyword.declaration.throws.java +// ^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + private static int methodthrows() throws java.myexception {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java +// ^ meta.function.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.throws.java +// ^^^^^^^^^^ meta.generic.java +// ^^ meta.function.java +// ^ - meta.function +// ^^^^^^^^^^^^^^^^^ meta.path.java - meta.path meta.path +// ^^^^^^^^ meta.path.java meta.path.java +// ^ meta.path.java - meta.path meta.path +// ^ - meta.path +//^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^^^^ keyword.declaration.throws.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + void primitiveVarArgs(char... values) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^^ storage.type.primitive.java +// ^^^ keyword.operator.variadic.java +// ^^^^^^ variable.parameter.java + + void finalPrimitiveVarArgs(final int... values) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^ keyword.operator.variadic.java +// ^^^^^^ variable.parameter.java + + void annotatedPrimitiveVarArgs(@anno int @foo.anno... values) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^^^ meta.annotation.identifier.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^ meta.annotation.identifier.java +// ^^^ keyword.operator.variadic.java +// ^^^^^^ variable.parameter.java + + void classVarArgs(String... values) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^^^^ storage.type.class.java +// ^^^ keyword.operator.variadic.java +// ^^^^^^ variable.parameter.java + + void invalidPrivateClassVarArgs(private String... values) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^ - meta.function.parameters.java +// ^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^^^^ storage.type.class.java +// ^^^ keyword.operator.variadic.java +// ^^^^^^ variable.parameter.java + + void invalidVarArgs(var... values) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^^^ keyword.operator.variadic.java +// ^^^ variable.parameter.java + + void arrayMethod(byte [] [] a, int b, byte[] c) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java +// ^ - meta.function.parameters.java +// ^^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^^ storage.modifier.array.java +// ^ variable.parameter.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^ variable.parameter.java + + int[] arrayMethod(int a[], String b[])[] {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^ meta.function.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^ meta.function.java - meta.function meta.group - meta.function meta.block +// ^^ meta.function.java meta.block.java +//^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^^ storage.modifier.array.java +// ^^^^^^ storage.type.class.java +// ^ variable.parameter.java +// ^^ storage.modifier.array.java + + @anno public int[][] arrayMethod( +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^ meta.function.identifier.java entity.name.function.java +// ^^ meta.function.parameters.java meta.group.java +//^^^^^ meta.annotation.identifier.java +// ^^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^ storage.modifier.array.java +// ^ punctuation.section.group.begin.java + + Map[] mapping, +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^^^ storage.type.class.java +// ^^^^^^^^^^^^ meta.generic.java +// ^ punctuation.section.generic.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^ storage.modifier.array.java +// ^^^^^^^ variable.parameter.java +// ^ punctuation.separator.comma.java + + @Anno int[] arg[], +// ^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^^^^^ meta.annotation.identifier.java +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^^^ variable.parameter.java +// ^^ storage.modifier.array.java +// ^ punctuation.separator.comma.java + + final int @Anno [] @Anno [] arg @Anno [] @Anno [], +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^ variable.parameter.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java + + String@Anno[]@Anno[]arg@Anno[]@Anno[] +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^^^^^^ storage.type.class.java +// ^^^^^^^^^^^^^^^^ meta.generic.java +// ^ punctuation.section.generic.begin.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.separator.comma.java +// ^^^ storage.type.primitive.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.generic.end.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^ variable.parameter.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java + ) @Anno [] @ path . Anno (param = value) [] {} +//^ meta.function.parameters.java meta.group.java punctuation.section.group.end.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.java - meta.function meta.function +// ^^ meta.function.java meta.block.java - meta.function meta.function +// ^ - meta.function +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java + + void genericTypeMethod(T obj); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^ meta.function.modifier.java meta.generic.declaration.java +// ^ meta.function.modifier.java - meta.generic +// ^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^^^^^^ meta.function.parameters.java meta.group.java +// ^ - meta.function +//^ punctuation.section.generic.begin.java +// ^ variable.parameter.type +// ^ punctuation.section.generic.end.java +// ^^^^ storage.type.void.java +// ^^^^^^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ storage.type.class.java +// ^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + public static Set unmodifiableSet(Set set); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^ meta.function.modifier.java meta.generic.declaration.java +// ^^^^^^^^^^^^^^^ meta.function.modifier.java - meta.generic +// ^^^ meta.function.return-type.java - meta.generic +// ^^^ meta.function.return-type.java meta.generic.java +// ^ meta.function.return-type.java - meta.generic +// ^^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^^^ meta.function.parameters.java meta.group.java - meta.generic +// ^^^ meta.function.parameters.java meta.group.java meta.generic.java +// ^^^^^ meta.function.parameters.java meta.group.java - meta.generic +// ^ - meta.function +//^ punctuation.section.generic.begin.java +// ^ variable.parameter.type +// ^ punctuation.section.generic.end.java +// ^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + public static T genericTypeMethod(Collection, Sink) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^ meta.function.modifier.java - meta.generic +// ^^^ meta.function.modifier.java meta.generic.declaration.java +// ^ meta.function.modifier.java - meta.generic +// ^^ meta.function.return-type.java - meta.generic +// ^^^^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^^^^^^^^^^^ meta.generic.java +// ^^^ meta.generic.java +// ^ meta.function.java +// ^^ meta.function.java meta.block.java +// ^ - meta.function +//^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^ variable.parameter.type.java +// ^ storage.type.class.java +// ^^^^^^^^^^^^^^^^^ entity.name.function.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^^^ storage.modifier.extends.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.separator.comma.java - meta.generic.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + protected static > +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^^^^^^^^^^^ meta.function.modifier.java - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^ meta.function.modifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^^^^^^^^^^^ meta.function.modifier.java meta.generic.declaration.java meta.generic.java +// ^ meta.function.modifier.java meta.generic.declaration.java - meta.generic meta.generic +// ^ meta.function.modifier.java - meta.generic +//^^^^^^^^^ storage.modifier.java +// ^^^^^^ storage.modifier.java +// ^ punctuation.section.generic.begin.java +// ^ variable.parameter.type.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^ keyword.declaration.super.java +// ^ storage.type.class.java +// ^^ punctuation.section.generic.end.java + T max(Collection coll); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^ meta.function.modifier.java +// ^^ meta.function.return-type.java +// ^^^ meta.function.identifier.java +// ^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^ - meta.function +// ^ storage.type.class.java +// ^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + @RunWith(JUnit4.class) +//^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function - meta.annotation meta.annotation +//^^^^^^^^ meta.function.modifier.java meta.annotation.identifier.java +// ^^^^^^^^^^^^^^ meta.function.modifier.java meta.annotation.parameters.java meta.group.java +// ^ meta.function.modifier.java - meta.annotation +//^ punctuation.definition.annotation.java +// ^^^^^^^ variable.annotation.java +// ^ punctuation.section.group.begin.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java - storage.type.java +// ^ punctuation.section.group.end.java + public +//^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^ meta.function.modifier.java storage.modifier.java +// ^ meta.function.modifier.java - storage + static +//^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^ meta.function.modifier.java - storage +// ^^^^^^ meta.function.modifier.java storage.modifier.java +// ^ meta.function.modifier.java - storage + +//^^^^ - meta.function meta.function +//^^^ meta.function.modifier.java meta.generic.declaration.java +// ^ meta.function.modifier.java - meta.generic +// ^ punctuation.section.generic.end.java + void +//^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^ meta.function.modifier.java +// ^^^^ meta.function.return-type.java storage.type.void.java +// ^^ meta.function.return-type.java - storage + genericMethod +//^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^ meta.function.return-type.java - storage - entity +// ^^^^^^^^^^^^^ meta.function.identifier.java entity.name.function.java +// ^ meta.function.identifier.java - entity + ( +//^^^^ - meta.function meta.function +//^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ punctuation.section.group.begin.java + SomeType root +//^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^ variable.parameter.java + ) +//^^^^ - meta.function meta.function +//^^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^ punctuation.section.group.end.java + throws +//^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^ meta.function.java +// ^^^^^^^ meta.function.throws.java +// ^^^^^^ keyword.declaration.throws.java + Exception +//^^^^^^^^^^^^^^^^ meta.function.throws.java - meta.function meta.function +// ^^^^^^^^^ storage.type.class.java + , IOException, +//^^^^^^^^^^^^^^^^^^^^^ meta.function.throws.java - meta.function meta.function +// ^ punctuation.separator.comma.java +// ^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.separator.comma.java + SAXException +//^^^^^^^^^^^^^^^^^^^ meta.function.throws.java - meta.function meta.function +// ^^^^^^^^^^^^ storage.type.class.java + { +//<- meta.function.throws.java - meta.function meta.function +//^^ meta.function.java meta.block.java - meta.function meta.function +//^ punctuation.section.block.begin.java + } +//^ meta.function.java meta.block.java punctuation.section.block.end.java +// ^ - meta.function + + @RunWith(JUnit4.class) +//^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function - meta.annotation meta.annotation +//^^^^^^^^ meta.function.modifier.java meta.annotation.identifier.java +// ^^^^^^^^^^^^^^ meta.function.modifier.java meta.annotation.parameters.java meta.group.java +// ^ meta.function.modifier.java - meta.annotation +//^ punctuation.definition.annotation.java +// ^^^^^^^ variable.annotation.java +// ^ punctuation.section.group.begin.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java - storage.type.java +// ^ punctuation.section.group.end.java + public void someReallyReallyLongMethodNameThatMakesTheBraceOverflowToTheNextLine( +//^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.identifier.java entity.name.function.java +// ^ meta.function.parameters.java meta.group.java punctuation.section.group.begin.java + WITHSOMEPARAMS foo, +// ^ meta.function.parameters.java storage.type.class.java +// ^ meta.function.parameters.java variable.parameter.java + Generic bar) +// ^ meta.function.parameters.java storage.type.class.java +// ^^^^^^^ meta.generic.java +// ^ meta.function.parameters.java variable.parameter.java +// ^ punctuation.section.group.end + throws Exception { +// ^ meta.function.throws.java keyword.declaration.throws.java +// ^ meta.function.throws.java storage.type.class.java + return someMethod (new Function() { +// ^ - meta.function-call +// ^^^^^^^^^^^ meta.function-call.identifier.java - meta.function-call meta.function-call +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function-call.arguments.java meta.group.java - meta.function-call meta.function-call +// ^ meta.class.java punctuation.section.block.begin.java +// ^ - variable +// ^^^^^^^^^^ variable.function.java +// ^ - variable + @Override + public V apply(V input) { +// ^ storage.type.class.java +// ^^^^^^^^^ meta.function.parameters.java +// ^ storage.type.class.java +// ^ variable.parameter.java +// ^ meta.function + return input; + } +// ^ meta.function + }, executor); +// ^^^^^^^^^^^^^ meta.function-call.arguments.java meta.group.java +// ^ meta.class.java punctuation.section.block.end.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java - meta.function-call + } +//^ meta.function.java punctuation.section.block.end.java + +} +// <- meta.class.java punctuation.section.block.end.java + + +/****************************************************************************** + * Method Declaration With Receiver Arguments Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4 + *****************************************************************************/ + +class ReceiverArgTests { + + // Illegal: Top-level constructors can't contain receiver parameters, + // but the syntax does not destinguish top-level and nested classses + ReceiverArgTests(ReceiverArgTests this, A this) {} +//^^^^^^^^^^^^^^^^ meta.function.identifier.java - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +//^^^^^^^^^^^^^^^^ entity.name.function.constructor.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.separator.comma.java +// ^ storage.type.class.java +// ^^^^ invalid.illegal.identifier.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + void method(ReceiverArgTests this, A this, B super, C par)[] {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^ meta.function.return-type.java +// ^^^^^^ meta.function.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +// ^^^ meta.function.java +// ^^ meta.function.java meta.block.java +//^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.separator.comma.java +// ^ storage.type.class.java +// ^^^^ invalid.illegal.identifier.java +// ^ punctuation.separator.comma.java +// ^ storage.type.class.java +// ^^^^^ invalid.illegal.identifier.java +// ^ punctuation.separator.comma.java +// ^ storage.type.class.java +// ^^^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + // Illegal: Static methods can't contain receiver parameters, + // but the syntax does not destinguish them. + static void method(ReceiverArgTests this) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function - meta.function meta.function +//^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^ meta.function.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java +//^^^^^^ storage.modifier.java +// ^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + class A { + A(ReceiverArgTests ReceiverArgTests.this, A ReceiverArgTests.this) {} +// ^ entity.name.function.constructor.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.separator.comma.java +// ^ storage.type.class.java +// ^^^^^^^^^^^^^^^^ variable.parameter.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^^ invalid.illegal.unexpected-member.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + A( +// ^ entity.name.function.constructor.java +// ^ punctuation.section.group.begin.java + /**/ ReceiverArgTests +// ^^^^ comment.block.empty.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java + /**/ ReceiverArgTests +// ^^^^ comment.block.empty.java +// ^ - meta.path +// ^^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java + /**/ . +// ^^^^^^^^ meta.path.java +// ^^^^ comment.block.empty.java +// ^ punctuation.accessor.dot.java - support - variable + /**/ this [] . illegal, +// ^^^^^^^^^ meta.path.java +// ^^^^^^^^^^^^^^^ - meta.path +// ^^^^ comment.block.empty.java +// ^^^^ variable.parameter.this.java - support +// ^^ invalid.illegal.unexpected-modifier.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^^^^^ invalid.illegal.unexpected-member.java +// ^ punctuation.separator.comma.java + /**/ , +// ^^^^ comment.block.empty.java +// ^ punctuation.separator.comma.java + /**/ A +// ^^^^ comment.block.empty.java +// ^ storage.type.class.java - meta.path + /**/ ReceiverArgTests +// ^^^^ comment.block.empty.java +// ^^^^^^^^^^^^^^^^ variable.parameter.java - meta.path - support + /**/ . +// ^^^^^^^ - meta.path +// ^^^^ comment.block.empty.java +// ^ invalid.illegal.unexpected-accessor.java - meta.path + /**/ this[].foo[][].bar +// ^^^^^^^^^^^^^^^^^^^^^^^ - meta.path +// ^^^^ comment.block.empty.java +// ^^^^ invalid.illegal.unexpected-member.java - meta.path +// ^^ invalid.illegal.unexpected-modifier.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^ invalid.illegal.unexpected-member.java +// ^^^^ invalid.illegal.unexpected-modifier.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^ invalid.illegal.unexpected-member.java + /**/ ) {} +// ^^^^ comment.block.empty.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + // OK: the ReceiverArgTests parameter represents the instance + // of A for which A.m() is invoked. + void method(A this) {} +// ^^^^^ meta.function.return-type.java - meta.function meta.function +// ^^^^^^ meta.function.identifier.java - meta.function meta.function +// ^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ storage.type.class.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + class B { + // OK: the ReceiverArgTests parameter represents the instance + // of A which immediately encloses the instance of B being constructed. + B(ReceiverArgTests.A A.this) {} +// ^ entity.name.function.constructor.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^^^^^^ meta.path.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + // FAIL: qualified parameter is a receiver and must end with "this". + B(ReceiverArgTests.A A.fail) {} +// ^ entity.name.function.constructor.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^^^^^^ meta.path.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^ invalid.illegal.identifier.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + // OK: the receiver parameter represents the instance + // of B for which B.m() is invoked. + void method(ReceiverArgTests.A.B this) {} +// ^^^^^ meta.function.return-type.java - meta.function meta.function +// ^^^^^^ meta.function.identifier.java - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^ - meta.path +// ^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^^^ - meta.path +// ^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + void method(ReceiverArgTests.A.B A.B.this) {} +// ^^^^^ meta.function.return-type.java - meta.function meta.function +// ^^^^^^ meta.function.identifier.java - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^ - meta.path +// ^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^ - meta.path +// ^^^^^^^^ meta.path.java +// ^ - meta.path +// ^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + void method(receiverargtests.a.b a.b.this) {} +// ^^^^^ meta.function.return-type.java - meta.function meta.function +// ^^^^^^ meta.function.identifier.java - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^ - meta.path +// ^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^ - meta.path +// ^^^^^^^^ meta.path.java +// ^ - meta.path +// ^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + void method(@á receiverargtests . @ß a . @µ.c b @a a . @b.c b . @d . e(f="") this) {} +// ^^^^^ meta.function.return-type.java - meta.function meta.function +// ^^^^^^ meta.function.identifier.java - meta.function meta.function +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java meta.group.java - meta.function meta.function +// ^^^^ - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.path.java - meta.path meta.path +// ^^^^ meta.path.java meta.path.java +// ^^ meta.path.java - meta.path meta.path +// ^ - meta.path +// ^^^^^^^ meta.path.java - meta.path meta.path +// ^^^^ meta.path.java meta.path.java +// ^^^^^ meta.path.java - meta.path meta.path +// ^^^^^^ meta.path.java meta.path.java +// ^^^^^^^^^^^ meta.path.java - meta.path meta.path +// ^^^^^ - meta.path +// ^^^^ storage.type.void.java +// ^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^^^ meta.generic.java +// ^ punctuation.accessor.dot.java +// ^^ meta.annotation.identifier.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^ meta.annotation.identifier.java +// ^ storage.type.class.java +// ^^ meta.annotation.identifier.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^ meta.annotation.identifier.java +// ^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^ meta.annotation.identifier.java +// ^^^^^^ meta.annotation.parameters.java meta.group.java +// ^^^^ variable.parameter.this.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + } +// ^ meta.class.java meta.block.java meta.class.java meta.block.java meta.class.java meta.block.java punctuation.section.block.end.java + } +//^ meta.class.java meta.block.java meta.class.java meta.block.java punctuation.section.block.end.java +} +//<- meta.class.java meta.block.java punctuation.section.block.end.java + + +/****************************************************************************** + * Invalid Class Member Fallback Tests + * Things that are not supported by Java but might need to be handled by the + * syntax to prevent highligthing from breaking due to incomplete code blocks. + * + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-8.html#jls-8.4 + *****************************************************************************/ + +class InvalidMemberTests { + + int if(true) +//^^^^^^^^^^^^ - meta.function +//^^^ storage.type.primitive.java +// ^^ - entity + + int class MyClass +//^^^^^^^^^^^^^^^^^ - meta.function +//^^^ storage.type.primitive.java +// ^^ - entity + + int package dump +//^^^^^^^^^^^^^^^^ - meta.function +//^^^ storage.type.primitive.java +// ^^ - entity + +} +// <- meta.class.java punctuation.section.block.end.java + + +/****************************************************************************** + * Local Variable Declaration Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.4 + *****************************************************************************/ + +class LocalVariableDeclarationTests { + + void declarePrimitiveTypes() { + + int +// ^^^^^ - meta.declaration +// ^^^ storage.type.primitive.java + + int foo +// ^^^^ meta.declaration.type.java +// ^^^^ meta.declaration.identifier.java +// ^^^ storage.type.primitive.java +// ^^^ variable.other.java + + int foo; +// ^^^^ meta.declaration.type.java +// ^^^ meta.declaration.identifier.java +// ^ - meta.declaration +// ^^^ storage.type.primitive.java +// ^^^ variable.other.java +// ^ punctuation.terminator.java + + int FOO; +// ^^^^ meta.declaration.type.java +// ^^^ meta.declaration.identifier.java +// ^ - meta.declaration +// ^^^ storage.type.primitive.java +// ^^^ constant.other.java +// ^ punctuation.terminator.java + + int foo, bar; +// ^ - meta.declaration +// ^^^^ meta.declaration.type.java +// ^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^^ meta.declaration.identifier.java +// ^ - meta.declaration +// ^^^ storage.type.primitive.java +// ^^^ variable.other.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.java +// ^ punctuation.terminator.java + + int foo =, bar =; +// ^ - meta.declaration +// ^^^^ meta.declaration.type.java +// ^^^^ meta.declaration.identifier.java +// ^^ meta.declaration.java +// ^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^ - meta.declaration +// ^^^ storage.type.primitive.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ punctuation.terminator.java + + int foo = 0, bar = CONST; +// ^ - meta.declaration +// ^^^^ meta.declaration.type.java +// ^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^ meta.declaration.value.java +// ^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^^^^ meta.declaration.value.java +// ^ - meta.declaration +// ^^^ storage.type.primitive.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^^^ constant.other.java +// ^ punctuation.terminator.java + + int[] +// ^^^^^^ - meta.declaration +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java + + int [] +// ^^^^^^^ - meta.declaration +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java + + int[] foo +// ^^^^^^ meta.declaration.type.java +// ^^^^ meta.declaration.identifier.java +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^^^ variable.other.java + + int foo[], [] ; +// ^^^^ meta.declaration.type.java +// ^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^^ meta.declaration.identifier.java +// ^ - meta.declaration +// ^^^ storage.type.primitive.java +// ^^^ variable.other.java +// ^^ storage.modifier.array.java +// ^ punctuation.separator.comma.java +// ^^ storage.modifier.array.java +// ^ punctuation.terminator.java + + final int[] y = 10, z[] = 5; +// ^ - meta.declaration +// ^^^^^^^^^^^^ meta.declaration.type.java +// ^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^ meta.declaration.value.java +// ^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^ meta.declaration.value.java +// ^ - meta.declaration +// ^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ variable.other.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java + + @Number final int y @Dim1 [] @Dim2 [] = { {10, 1}, {5, 2} }; +// ^ - meta.declaration +// ^^^^^^^^^^^^^^^^^^ meta.declaration.type.java +// ^^^^^^^^^^^^^^^^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^^^^^^^^^^^^^^^^^^ meta.declaration.value.java +// ^ - meta.declaration +// ^^^^^^^ meta.annotation.identifier.java +// ^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^ variable.other.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.assignment.java + + @Number +// ^^^^^^^ meta.declaration.type.java meta.annotation.identifier.java +// ^ meta.declaration.type.java - meta.annotation + final +// ^^^^^ meta.declaration.type.java storage.modifier.java + int +// ^^^ meta.declaration.type.java storage.type.primitive.java + foo +// ^^^ meta.declaration.identifier.java variable.other.java + @Dim1 +// ^^^^^ meta.declaration.identifier.java meta.annotation.identifier.java +// ^ meta.declaration.identifier.java - meta.annotation + [] +// ^^ meta.declaration.identifier.java storage.modifier.array.java + = +// ^ meta.declaration.java keyword.operator.assignment.java + {0, 1} +// ^^^^^^ meta.declaration.value.java meta.braces.java + } +//^ meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java +// ^ meta.class.java meta.block.java - meta.function + + void declareObjectTypes() { + + TestClass ; +// ^^^^^^^^^ storage.type.class.java + + testclass ; +// ^^^^^^^^^ variable.other.java + + TestClass foo +// ^^^^^^^^^^ meta.declaration.type.java +// ^^^^ meta.declaration.identifier.java +// ^^^^^^^^^ storage.type.class.java +// ^^^ variable.other.java + + testclass foo +// ^^^^^^^^^^ meta.declaration.type.java +// ^^^^ meta.declaration.identifier.java +// ^^^^^^^^^ storage.type.class.java +// ^^^ variable.other.java + + TestClass foo; +// ^^^^^^^^^^ meta.declaration.type.java +// ^^^ meta.declaration.identifier.java +// ^ - meta.declaration +// ^^^^^^^^^ storage.type.class.java +// ^^^ variable.other.java +// ^ punctuation.terminator.java + + TestClass foo, bar; +// ^ - meta.declaration +// ^^^^^^^^^^ meta.declaration.type.java +// ^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^^ meta.declaration.identifier.java +// ^ - meta.declaration +// ^^^^^^^^^ storage.type.class.java +// ^^^ variable.other.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.java +// ^ punctuation.terminator.java + + TestClass foo =, bar =; +// ^ - meta.declaration +// ^^^^^^^^^^ meta.declaration.type.java +// ^^^^ meta.declaration.identifier.java +// ^^ meta.declaration.java +// ^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^ - meta.declaration +// ^^^^^^^^^ storage.type.class.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ punctuation.terminator.java + + TestClass foo = 0, bar = 10; +// ^ - meta.declaration +// ^^^^^^^^^^ meta.declaration.type.java +// ^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^ meta.declaration.value.java +// ^ meta.declaration.java +// ^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^ meta.declaration.value.java +// ^ - meta.declaration +// ^^^^^^^^^ storage.type.class.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^ constant.numeric.value.java +// ^ punctuation.terminator.java + + final TestClass[] y = 10, z[] = 5; +// ^ - meta.declaration +// ^^^^^^^^^^^^^^^^^^ meta.declaration.type.java +// ^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^ meta.declaration.value.java +// ^ meta.declaration.java +// ^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^ meta.declaration.value.java +// ^ - meta.declaration +// ^^^^^ storage.modifier.java +// ^^^^^^^^^ storage.type.class.java +// ^^ storage.modifier.array.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ variable.other.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java + + @Number final TestClass y @Dim1 [] @Dim2 [] = { {10, 1}, {5, 2} }; +// ^ - meta.declaration +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.declaration.type.java +// ^^^^^^^^^^^^^^^^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^^^^^^^^^^^^^^^^^^ meta.declaration.value.java +// ^ - meta.declaration +// ^^^^^^^ meta.annotation.identifier.java +// ^^^^^ storage.modifier.java +// ^^^^^^^^^ storage.type.class.java +// ^ variable.other.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.assignment.java + + @number final testclass y @dim1 [] @dim2 [] = { {10, 1}, {5, 2} }; +// ^ - meta.declaration +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.declaration.type.java +// ^^^^^^^^^^^^^^^^^^^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^^^^^^^^^^^^^^^^^^^^ meta.declaration.value.java +// ^ - meta.declaration +// ^^^^^^^ meta.annotation.identifier.java +// ^^^^^ storage.modifier.java +// ^^^^^^^^^ storage.type.class.java +// ^ variable.other.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.assignment.java + + foo.TestClass bar.baz; +// ^ - meta.declaration +// ^^^^^^^^^^^^^ meta.declaration.type.java meta.path.java +// ^ meta.declaration.type.java - meta.path +// ^^^^^^^ meta.declaration.identifier.java - meta.path +// ^ - meta.declaration +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ storage.type.class.java +// ^^^ variable.other.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^ invalid.illegal.unexpected-member.java + + foo.testclass bar.baz; +// ^ - meta.declaration +// ^^^^^^^^^^^^^ meta.declaration.type.java meta.path.java +// ^ meta.declaration.type.java - meta.path +// ^^^^^^^ meta.declaration.identifier.java - meta.path +// ^ - meta.declaration +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ storage.type.class.java +// ^^^ variable.other.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^ invalid.illegal.unexpected-member.java + + a e = new a(){}; +// ^^^^^^ - meta.instantiation +// ^^ meta.declaration.type.java +// ^^ meta.declaration.identifier.java +// ^ meta.declaration.java +// ^ meta.declaration.value.java +// ^^^^^^^^^ meta.declaration.value.java meta.instantiation.java +// ^ - meta.declaration - meta.instantiation +// ^ storage.type.class.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^ keyword.other.storage.new.java +// ^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + } + + + void declareGenericTypes() { + + List x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^^^^^^^^ meta.declaration.type.java meta.generic.java - meta.path +// ^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^^^^^^^^ meta.generic.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + List x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.type.java meta.generic.java - meta.path +// ^^^^^^^^^^^^^^^^ meta.declaration.type.java meta.generic.java meta.path.java +// ^ meta.declaration.type.java meta.generic.java - meta.path +// ^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + List x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^^^^^ meta.declaration.type.java meta.generic.java - meta.path +// ^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + List x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.type.java meta.generic.java - meta.path +// ^^^^^^^^^^^^ meta.declaration.type.java meta.generic.java meta.path.java +// ^ meta.declaration.type.java meta.generic.java - meta.path +// ^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + List x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^^^^^^^ meta.declaration.type.java meta.generic.java - meta.path +// ^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.generic.end.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + List x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.type.java meta.generic.java - meta.path +// ^^^^^^^^^^^^^^^^ meta.declaration.type.java meta.generic.java meta.path.java +// ^^^ meta.declaration.type.java meta.generic.java - meta.path +// ^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^ storage.type.class.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.generic.end.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + List x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^^^^^^^ meta.declaration.type.java meta.generic.java - meta.path +// ^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^^^^^^^ meta.generic.java +// ^^^ storage.type.class.java +// ^^ storage.modifier.array.java + + List[][] x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^^^^^^^^^ meta.declaration.type.java meta.generic.java - meta.path +// ^^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^ storage.type.primitive.java +// ^^^^ storage.modifier.array.java +// ^ punctuation.section.generic.end.java +// ^^^^ storage.modifier.array.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + List x; +// ^^^^ meta.declaration.type.java - meta.generic - meta.path +// ^^^^^^^^^^^^^^^ meta.declaration.type.java meta.generic.java - meta.path +// ^ meta.declaration.type.java - meta.generic - meta.path +// ^ meta.declaration.identifier.java - meta.generic - meta.path +// ^ - meta.declaration +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.section.generic.end.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + @anno foo . @anno TestClass @anno . anno [] bar . baz; +// ^ - meta.declaration +// ^^^^^ meta.declaration.type.java meta.annotation.identifier.java - meta.path +// ^ meta.declaration.type.java - meta.annotation - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.declaration.type.java meta.path.java +// ^ meta.declaration.type.java - meta.path +// ^^^^^^^^^^^^ meta.declaration.type.java meta.annotation.identifier.java meta.path.java +// ^^^^ meta.declaration.type.java - meta.annotation - meta.path +// ^^^^^^^^^ meta.declaration.identifier.java - meta.annotation - meta.path +// ^ - meta.declaration +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.annotation.java +// ^^ storage.modifier.array.java +// ^^^ variable.other.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^ invalid.illegal.unexpected-member.java +// ^ punctuation.terminator.java + + @anno foo . @anno testclass @anno . anno [] bar . baz; +// ^ - meta.declaration +// ^^^^^ meta.declaration.type.java meta.annotation.identifier.java - meta.path +// ^ meta.declaration.type.java - meta.annotation - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.declaration.type.java meta.path.java +// ^ meta.declaration.type.java - meta.path +// ^^^^^^^^^^^^ meta.declaration.type.java meta.annotation.identifier.java meta.path.java +// ^^^^ meta.declaration.type.java - meta.annotation - meta.path +// ^^^^^^^^^ meta.declaration.identifier.java - meta.annotation - meta.path +// ^ - meta.declaration +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.annotation.java +// ^^ storage.modifier.array.java +// ^^^ variable.other.java +// ^ invalid.illegal.unexpected-accessor.java +// ^^^ invalid.illegal.unexpected-member.java +// ^ punctuation.terminator.java + + class a{{ +// ^^^^^ meta.function.java meta.class.java +// ^^ meta.function.java meta.class.identifier.java - meta.generic +// ^^^ meta.function.java meta.class.identifier.java meta.generic.declaration.java +// ^^ meta.function.java meta.class.java meta.block.java - meta.generic +// ^^^^^ keyword.declaration.class.java +// ^ entity.name.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.parameter.type.java +// ^ punctuation.section.generic.end.java +// ^^ punctuation.section.block.begin.java + aa; +// ^ meta.declaration.type.java - meta.generic +// ^^^ meta.declaration.type.java meta.generic.java +// ^ meta.declaration.identifier.java - meta.generic +// ^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ variable.other.java +// ^ punctuation.terminator.java + }} +// ^^ punctuation.section.block.end.java + } + + void declareVarTypes() { + + var +// ^^^ storage.type.variant.java + + var x, y; +// ^^^ storage.type.variant.java +// ^ variable.other.java +// ^ punctuation.separator.comma.java +// ^ variable.other.java +// ^ punctuation.terminator.java + + var x = "String"; +// ^^^ storage.type.variant.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java + + final var y = 10; +// ^^^^^ storage.modifier.java +// ^^^ storage.type.variant.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java + + final var y.b = 10; +// ^^^^^ storage.modifier.java +// ^^^ storage.type.variant.java +// ^ variable.other.java +// ^ invalid.illegal.unexpected-accessor.java +// ^ invalid.illegal.unexpected-member.java +// ^ keyword.operator.assignment.java + + final var[] y = 10, z[] = 5; +// ^^^^^ storage.modifier.java +// ^^^ storage.type.variant.java +// ^^ invalid.illegal.unexpected-modifier.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ punctuation.terminator.java + + @Number final var y @Dim1 [] @Dim2 [] = { {10, 1}, {5, 2} }; +// ^^^^^^^ meta.annotation.identifier.java +// ^^^^^ storage.modifier.java +// ^^^ storage.type.variant.java +// ^ variable.other.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java +// ^^^^^ meta.annotation.identifier.java +// ^^ storage.modifier.array.java + } +} + + +/****************************************************************************** + * Labeled Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.7 + *****************************************************************************/ + +class LabeledStatementTests { + + void run() { + + label: +// ^^^^^ entity.name.label.java +// ^ punctuation.separator.colon.java + + label: if () {} else {} +// ^^^^^ entity.name.label.java +// ^ punctuation.separator.colon.java +// ^^^^^^^^ meta.statement.conditional.if.java +// ^^^^^^^ meta.statement.conditional.else.java + + label: run(); +// ^^^^^ entity.name.label.java +// ^ punctuation.separator.colon.java +// ^^^^^ meta.function-call + + label: a = b; +// ^^^^^ entity.name.label.java +// ^ punctuation.separator.colon.java + } +} + + + +/****************************************************************************** + * If Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.9 + *****************************************************************************/ + +class IfStatementTests { + + void run() { + + if$ ; +// ^^^ variable.other.java - keyword + + $if ; +// ^^^ variable.other.java - keyword + + if +// ^^^ meta.statement.conditional.if.java +// ^^ keyword.control.conditional.if.java + + if foo +// ^^^^^^^ meta.statement.conditional.if.java +// ^^ keyword.control.conditional.if.java +// ^^^ variable.other.java + + if (foo) +// ^^^ meta.statement.conditional.if.java - meta.group +// ^^^^^ meta.statement.conditional.if.java meta.group.java +// ^ meta.statement.conditional.if.java - meta.group +// ^^ keyword.control.conditional.if.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java + + if (foo) {} +// ^^^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^ meta.statement.conditional.if.java meta.group.java +// ^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.block - meta.statement.conditional.if meta.group +// ^^ meta.statement.conditional.if.java meta.block.java +// ^ - meta.statement.conditional.if +// ^^ keyword.control.conditional.if.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + if (foo {} +// ^^^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^ meta.statement.conditional.if.java meta.group.java +// ^^ meta.statement.conditional.if.java meta.block.java +// ^ - meta.statement.conditional.if +// ^^ keyword.control.conditional.if.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + if (hello(world) { return false } +// ^^^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^^^^^^^^^^ meta.statement.conditional.if.java meta.group.java +// ^^^^^^^^^^^^^^^^ meta.statement.conditional.if.java meta.block.java +// ^ - meta.statement.conditional.if +// ^ punctuation.section.block.begin.java +// ^^^^^^ keyword.control.flow.return.java +// ^^^^^ constant.language.boolean.java +// ^ punctuation.section.block.end.java + + if (foo) else +// ^^^^^^^^^ - meta.statement.conditional.else +// ^^^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^ meta.statement.conditional.if.java meta.group.java +// ^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.block - meta.statement.conditional.if meta.group +// ^^^^^ meta.statement.conditional.else.java - meta.statement.conditional.if +// ^^ keyword.control.conditional.if.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^^^^ keyword.control.conditional.else.java + + if (foo) {} else {} +// ^^^^^^^^^^^^ - meta.statement.conditional.else +// ^^^ meta.statement.conditional.if.java - meta.group +// ^^^^^ meta.statement.conditional.if.java meta.group.java +// ^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.block - meta.statement.conditional.if meta.group +// ^^ meta.statement.conditional.if.java meta.block.java +// ^^^^^^^^ - meta.statement.conditional.if +// ^^^^^ meta.statement.conditional.else.java - meta.statement.conditional.else meta.block +// ^^ meta.statement.conditional.else.java meta.block.java +// ^ - meta.statement.conditional.if - meta.statement.conditional.else +// ^^ keyword.control.conditional.if.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// ^^^^ keyword.control.conditional.else.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + if (foo) else if (bar) else +// ^^^^^^^^^ - meta.statement.conditional.else +// ^^^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^ meta.statement.conditional.if.java meta.group.java +// ^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.block - meta.statement.conditional.if meta.group +// ^^^^^ meta.statement.conditional.else.java - meta.statement.conditional.if +// ^^ keyword.control.conditional.if.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^^^^ keyword.control.conditional.else.java +// ^^^^^^^^^ - meta.statement.conditional.else +// ^^^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^ meta.statement.conditional.if.java meta.group.java +// ^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.block - meta.statement.conditional.if meta.group +// ^^^^^ meta.statement.conditional.else.java - meta.statement.conditional.if +// ^^ keyword.control.conditional.if.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^^^^ keyword.control.conditional.else.java + + if (foo() == true) fun() else if (bar != 0) bar = 1 else baz++ +// ^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.statement.conditional.else +// ^^^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^^^^^^^^^^^ meta.statement.conditional.if.java meta.group.java +// ^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^^ meta.statement.conditional.if.java +// ^^^^^ meta.statement.conditional.else.java - meta.statement.conditional.if +// ^^^^^^^^^^^^^^^^^^^^^^ - meta.statement.conditional.else +// ^^^ meta.statement.conditional.if.java - meta.statement.conditional.if meta.group +// ^^^^^^^^^^ meta.statement.conditional.if.java meta.group.java +// ^^^^^ meta.statement.conditional.else.java - meta.statement.conditional.if +// ^^ keyword.control.conditional.if.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.function.java +// ^^ keyword.operator.comparison.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.section.group.end.java +// ^^^ variable.function.java +// ^^^^ keyword.control.conditional.else.java + } +} + + +/****************************************************************************** + * Assert Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.10 + *****************************************************************************/ + +class AssertStatementTests { + + void run() { + + assert0; +// ^^^^^^^ variable.other.java - keyword + + assert$; +// ^^^^^^^ variable.other.java - keyword + + $assert; +// ^^^^^^^ variable.other.java - keyword + + assert +// ^ - meta.statement.conditional.assertion +// ^^^^^^^ meta.statement.conditional.assertion.java +// ^ - keyword +// ^^^^^^ keyword.control.flow.assert.java +// ^ - keyword + + assert ; +// ^^^^^^^^ meta.statement.conditional.assertion.java +// ^ - meta.statement.conditional.assertion +// ^ - keyword +// ^^^^^^ keyword.control.flow.assert.java +// ^^ - keyword +// ^ punctuation.terminator.java + + assert true; +// ^ - meta.statement.conditional.assertion +// ^^^^^^^ meta.statement.conditional.assertion.java +// ^ - meta.statement.conditional.assertion +// ^ - keyword +// ^^^^^^ keyword.control.flow.assert.java +// ^ - keyword - constant +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + assert : +// ^ - meta.statement.conditional.assertion +// ^^^^^^^^^ meta.statement.conditional.assertion.java +// ^ - keyword +// ^^^^^^ keyword.control.flow.assert.java +// ^ - keyword - punctuation +// ^ punctuation.separator.expressions.java + + assert : ; +// ^^^^^^^^^^ meta.statement.conditional.assertion.java +// ^ - meta.statement.conditional.assertion +// ^ - keyword +// ^^^^^^ keyword.control.flow.assert.java +// ^ - keyword - punctuation +// ^ punctuation.separator.expressions.java +// ^ - punctuation +// ^ punctuation.terminator.java + +// Note: Only two expressions are allowed, but we don't care here. + assert : : ; +// ^ - meta.statement.conditional.assertion +// ^^^^^^^^^^^ meta.statement.conditional.assertion.java +// ^ - meta.statement.conditional.assertion +// ^ - keyword +// ^^^^^^ keyword.control.flow.assert.java +// ^ - keyword - punctuation +// ^ punctuation.separator.expressions.java +// ^ - punctuation +// ^ punctuation.separator.expressions.java +// ^ punctuation.terminator.java + + assert foo():bar.baz(); +// ^ - meta.statement.conditional.assertion +// ^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.assertion.java +// ^ - meta.statement.conditional.assertion +// ^ - keyword +// ^^^^^^ keyword.control.flow.assert.java +// ^ - keyword - variable +// ^^^ variable.function.java +// ^ punctuation.separator.expressions.java +// ^^^ variable.other.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.function.java +// ^ punctuation.terminator.java + + assert scale > -100 : foo == true; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.assertion.java +// ^^^^^^ keyword.control.flow.assert.java +// ^^^^^ variable.other.java +// ^ keyword.operator.comparison.java +// ^ keyword.operator.arithmetic.java +// ^^^ constant.numeric.value.java +// ^ punctuation.separator.expressions.java +// ^^^ variable.other.java +// ^^ keyword.operator.comparison.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + assert int foo=0; +// ^^^^^^^ meta.statement.conditional.assertion.java +// ^^^^ meta.declaration.type.java - meta.statement.conditional.assertion +// ^^^ meta.declaration.identifier.java - meta.statement.conditional.assertion +// ^ meta.declaration.java - meta.statement.conditional.assertion +// ^ meta.declaration.value.java - meta.statement.conditional.assertion + + assert if (true) {} +// ^^^^^^^ meta.statement.conditional.assertion.java +// ^^^^^^^^^^^^ meta.statement.conditional.if.java - meta.statement.conditional.assertion + + assert while (true) {} +// ^^^^^^^ meta.statement.conditional.assertion.java +// ^^^^^^^^^^^^^^^ meta.statement.loop.while.java - meta.statement.conditional.assertion + + } +//^ meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java +} + + +/****************************************************************************** + * Switch Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.11 + *****************************************************************************/ + +class SwitchStatementTests { + + void run() { + + switch$ ; +// ^^^^^^^ variable.other.java - keyword + + $switch ; +// ^^^^^^^ variable.other.java - keyword + + switch +// ^^^^^^^ meta.statement.conditional.switch.java +// ^^^^^^ keyword.control.conditional.switch.java + + switch foo +// ^^^^^^^^^^^ meta.statement.conditional.switch.java +// ^^^^^^ keyword.control.conditional.switch.java +// ^^^ variable.other.java + + switch (foo) +// ^^^^^^^^^^^^^ - meta.statement.conditional.switch meta.statement.conditional.switch +// ^^^^^^^ meta.statement.conditional.switch.java +// ^^^^^ meta.statement.conditional.switch.java meta.group.java +// ^ meta.statement.conditional.switch.java +// ^^^^^^ keyword.control.conditional.switch.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java + + switch (foo) {} +// ^^^^^^^^^^^^^^^ - meta.statement.conditional.switch meta.statement.conditional.switch +// ^^^^^^^ meta.statement.conditional.switch.java +// ^^^^^ meta.statement.conditional.switch.java meta.group.java +// ^ meta.statement.conditional.switch.java +// ^^ meta.statement.conditional.switch.java meta.block.java +// ^^^^^^ keyword.control.conditional.switch.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + switch (foo {} +// ^^^^^^^^^^^^^^^ - meta.statement.conditional.switch meta.statement.conditional.switch +// ^^^^^^^ meta.statement.conditional.switch.java +// ^^^^^ meta.statement.conditional.switch.java meta.group.java +// ^^ meta.statement.conditional.switch.java meta.block.java +// ^^^^^^ keyword.control.conditional.switch.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + switch (foo%2) { + + case$ ; +// ^^^^^ variable.other.java - keyword + + $case ; +// ^^^^^ variable.other.java - keyword + + case +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^ keyword.control.conditional.case.java + + case : +// ^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^ punctuation.separator.expressions.java + + case 0: +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.expressions.java + + case 1: bar() +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.expressions.java +// ^^^ variable.function.java + + case 3: ; +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.expressions.java +// ^ punctuation.terminator.java + + case 5: {} +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.expressions.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + case "string": +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^ string.quoted.double.java +// ^ punctuation.separator.expressions.java + + case 'S': +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^ meta.string.java string.quoted.single.java +// ^ punctuation.definition.string.begin.java +// ^ constant.character.literal.java +// ^ punctuation.definition.string.end.java +// ^ punctuation.separator.expressions.java + + case '\n' + foo(): +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^ meta.string.java string.quoted.single.java +// ^ punctuation.definition.string.begin.java +// ^^ constant.character.escape.other.java +// ^ punctuation.definition.string.end.java +// ^ keyword.operator.arithmetic.java +// ^^^ variable.function.java +// ^ punctuation.separator.expressions.java + + case constant + 5: +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.expressions.java + + case (constant << 0x5) : +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java - meta.group +// ^^^^^^^^^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java meta.group.java +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.group +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java - meta.group +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^ variable.other.java +// ^^ keyword.operator.bitwise.java +// ^^ meta.number.integer.hexadecimal.java constant.numeric.base.java +// ^ meta.number.integer.hexadecimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.separator.expressions.java + + case null: +// ^^^^^^^^^^^^ meta.class.java meta.block.java meta.function.java meta.block.java meta.statement.conditional.switch.java meta.block.java +// ^^^^^ meta.statement.conditional.case.java +// ^^^^ meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.case.java +// ^^^^ keyword.control.conditional.case.java +// ^^^^ constant.language.null.java +// ^ punctuation.separator.expressions.java + + case super: +// ^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function.java meta.block.java meta.statement.conditional.switch.java meta.block.java +// ^^^^^ meta.statement.conditional.case.java +// ^^^^^ meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.case.java +// ^^^^ keyword.control.conditional.case.java +// ^^^^^ variable.language.super.java +// ^ punctuation.separator.expressions.java + + case CONSTANT +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^ constant.other.java + + case CONSTANT: +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + case constant +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^ constant.other.java + + case constant +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^ constant.other.java + { } +// ^^^ meta.statement.conditional.switch.java meta.block.java meta.block.java + + case constant +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^ constant.other.java + ; +// ^ meta.statement.conditional.switch.java meta.block.java punctuation.terminator.java + + case constant: +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + case EnumConst +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^^ constant.other.java + + case EnumConst: +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.label.java - meta.path +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.case.java +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + case module.CONSTANT: +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.case.java - meta.path +// ^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java meta.path.java +// ^ meta.statement.conditional.case.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + case MyClass.CONSTANT: +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.case.java - meta.path +// ^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java meta.path.java +// ^ meta.statement.conditional.case.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + case mod.sub.MyClass.EnumConst +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.case.java - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java meta.path.java +// ^^^^ keyword.control.conditional.case.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ constant.other.java + + case mod.sub.MyClass.EnumConst: +// ^^^^^ meta.statement.conditional.case.java - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java meta.path.java +// ^ meta.statement.conditional.case.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + case @anno mod . @anno sub . @anno MyClass . @anno EnumConst: +// ^^^^^ meta.statement.conditional.case.java - meta.path +// ^^^^^^ meta.statement.conditional.case.label.java - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java meta.path.java +// ^ meta.statement.conditional.case.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + case mod.sub.myclass.enumconst +// ^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.case.java - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java meta.path.java +// ^^^^ keyword.control.conditional.case.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ constant.other.java + break +// ^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.flow.break.java +// ^^^^^ keyword.control.flow.break.java + + case mod.sub.myclass.enumconst: +// ^ meta.statement.conditional.switch.java meta.block.java meta.statement.flow.break.java - meta.statement.conditional.case +// ^^^^^ meta.statement.conditional.case.java - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java meta.path.java +// ^ meta.statement.conditional.case.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + case @anno mod . @anno sub . @anno myclass . @anno enumconst: +// ^^^^^ meta.statement.conditional.case.java - meta.path +// ^^^^^^ meta.statement.conditional.case.label.java - meta.path +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java meta.path.java +// ^ meta.statement.conditional.case.java - meta.path +// ^^^^ keyword.control.conditional.case.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + + default : {} +// ^^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.default +// ^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.conditional.default.java +// ^^^^ meta.statement.conditional.switch.java meta.block.java - meta.statement.conditional.case +// ^^^^^^^ keyword.control.conditional.default.java +// ^ punctuation.separator.expressions.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + default$ ; +// ^^^^^^^^ variable.other.java - keyword + + $default ; +// ^^^^^^^^ variable.other.java - keyword + } +// ^ meta.statement.conditional.switch.java meta.block.java punctuation.section.block.end.java + } +//^ meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java +} +//<- meta.class.java meta.block.java punctuation.section.block.end.java + + +/****************************************************************************** + * Switch Expression Tests + * https://docs.oracle.com/javase/specs/jls/se16/html/jls-15.html#jls-15.28 + *****************************************************************************/ + +class SwitchExpressionsTests { + + void testArrowCaseLabels() { + int numLetters = switch (day) { +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^^^^^^^^^^^^^ meta.statement.conditional.switch.java +// ^^^^^^ keyword.control.conditional.switch.java + case null -> +// ^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function.java meta.block.java meta.statement.conditional.switch.java meta.block.java +// ^^^^^ meta.statement.conditional.case.java +// ^^^^^ meta.statement.conditional.case.label.java +// ^^ meta.statement.conditional.case.java +// ^^^^ keyword.control.conditional.case.java +// ^^^^ constant.language.null.java +// ^^ punctuation.separator.expressions.java + + case super -> +// ^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function.java meta.block.java meta.statement.conditional.switch.java meta.block.java +// ^^^^^ meta.statement.conditional.case.java +// ^^^^^^ meta.statement.conditional.case.label.java +// ^^ meta.statement.conditional.case.java +// ^^^^ keyword.control.conditional.case.java +// ^^^^^ variable.language.super.java +// ^^ punctuation.separator.expressions.java + + case MONDAY, FRIDAY, SUNDAY -> 6; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function.java meta.block.java meta.statement.conditional.switch.java meta.block.java +// ^^^^^ meta.statement.conditional.case.java +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java +// ^^ meta.statement.conditional.case.java +// ^^^^ - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^ constant.other.java +// ^ punctuation.separator.comma.java +// ^^^^^^ constant.other.java +// ^ punctuation.separator.comma.java +// ^^^^^^ constant.other.java +// ^^ punctuation.separator.expressions.java +// ^ constant.numeric.value.java +// ^ punctuation.terminator.java + case TUESDAY -> 7; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.block.java meta.function.java meta.block.java meta.statement.conditional.switch.java meta.block.java +// ^^^^^ meta.statement.conditional.case.java +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java +// ^^ meta.statement.conditional.case.java +// ^^^^ - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^ constant.other.java +// ^^ punctuation.separator.expressions.java +// ^ constant.numeric.value.java +// ^ punctuation.terminator.java + default -> { +// ^^^^^^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java +// ^^^^^^^^^^ meta.statement.conditional.default.java +// ^^^^ - meta.statement.conditional.case +// ^^^^^^^ keyword.control.conditional.default.java +// ^^ punctuation.separator.expressions.java +// ^ punctuation.section.block.begin.java + String s = day.toString(); + int result = s.length(); + yield result; +// ^^^^^^^^^^^^ meta.statement.flow.yield.java +// ^^^^^ keyword.control.flow.yield.java +// ^^^^^^ variable.other.java + } +// ^ punctuation.section.block.end.java + }; +// ^ meta.statement.conditional.switch.java meta.block.java punctuation.section.block.end.java +// ^ punctuation.terminator.java - meta.statement.conditional.switch + } +// ^ punctuation.section.block.end.java + + void testClassicCaseLabels(boolean startWeek) { + + int numLetters = switch (day) { + case startWeek ? MONDAY : FRIDAY : +// ^^^^^ meta.statement.conditional.case.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.case.label.java +// ^ meta.statement.conditional.case.java +// ^ - meta.statement.conditional.case +// ^^^^ keyword.control.conditional.case.java +// ^^^^^^^^^ variable.other.java +// ^ keyword.operator.ternary.java +// ^^^^^^ constant.other.java +// ^ keyword.operator.ternary.java +// ^^^^^^ constant.other.java +// ^ punctuation.separator.expressions.java + case SUNDAY: + yield 6; +// ^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.flow.yield.java +// ^^^^^ keyword.control.flow.yield.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java + case TUESDAY: + yield 7; +// ^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.flow.yield.java +// ^^^^^ keyword.control.flow.yield.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java + default: + throw new IllegalStateException("Invalid day: " + day); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.conditional.switch.java meta.block.java meta.statement.flow.throw.java +// ^^^^^ keyword.control.flow.throw.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^ string.quoted.double.java +// ^ keyword.operator.arithmetic.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + }; +// ^ meta.statement.conditional.switch.java meta.block.java punctuation.section.block.end.java +// ^ punctuation.terminator.java - meta.statement.conditional.switch + } +// ^ punctuation.section.block.end.java +} + + +/****************************************************************************** + * While Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.12 + *****************************************************************************/ + +class WhileStatementTests { + + void run() { + + while$ ; +// ^^^^^^ variable.other.java - keyword + + $while ; +// ^^^^^^ variable.other.java - keyword + + while +// ^^^^^^ meta.statement.loop.while.java +// ^^^^^ keyword.control.loop.while.java + + while false +// ^^^^^^^^^^^^ meta.statement.loop.while.java +// ^^^^^ keyword.control.loop.while.java +// ^^^^^ constant.language.boolean.java + + while (false) +// ^^^^^^^^^^^^^^ - meta.statement.loop.while meta.statement.loop.while +// ^^^^^^ meta.statement.loop.while.java - meta.group +// ^^^^^^^ meta.statement.loop.while.java meta.group.java +// ^ meta.statement.loop.while.java - meta.group +// ^^^^^ keyword.control.loop.while.java +// ^ punctuation.section.group.begin.java +// ^^^^^ constant.language.boolean.java +// ^ punctuation.section.group.end.java + + while (false) { } +// ^^^^^^^^^^^^^^^^^^ - meta.statement.loop.while meta.statement.loop.while +// ^^^^^^ meta.statement.loop.while.java - meta.group +// ^^^^^^^ meta.statement.loop.while.java meta.group.java +// ^ meta.statement.loop.while.java - meta.statement.loop.while.java meta.group - meta.statement.loop.while.java meta.block +// ^^^^ meta.statement.loop.while.java meta.block.java +// ^^^^^ keyword.control.loop.while.java +// ^ punctuation.section.group.begin.java +// ^^^^^ constant.language.boolean.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + while (false { } +// ^^^^^^^^^^^^^^^^^^ - meta.statement.loop.while meta.statement.loop.while +// ^^^^^^ meta.statement.loop.while.java +// ^^^^^^^ meta.statement.loop.while.java meta.group.java +// ^^^^ meta.statement.loop.while.java meta.block.java +// ^^^^^ keyword.control.loop.while.java +// ^ punctuation.section.group.begin.java +// ^^^^^ constant.language.boolean.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + } +} + + +/****************************************************************************** + * For Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.14 + *****************************************************************************/ + +class ForStatementTests { + + void run() { + + for$ ; +// ^^^^ variable.other.java - keyword + + $for ; +// ^^^^ variable.other.java - keyword + + for +// ^^^^ meta.statement.loop.for.java +// ^^^ keyword.control.loop.for.java +// ^ - keyword + + for () +// ^^^^^^ - meta.statement.loop.for meta.statement.loop.for +// ^^^^ meta.statement.loop.for.java - meta.group +// ^^ meta.statement.loop.for.java meta.group.java +// ^^^ keyword.control.loop.for.java +// ^ - keyword +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java + + for () {} +// ^^^^^^^^^ - meta.statement.loop.for meta.statement.loop.for +// ^^^^ meta.statement.loop.for.java - meta.group +// ^^ meta.statement.loop.for.java meta.group.java +// ^ meta.statement.loop.for.java - meta.block meta.block meta.block +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ - keyword +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + for ( {} +// ^^^^^^^^ - meta.statement.loop.for meta.statement.loop.for +// ^^^^ meta.statement.loop.for.java - meta.group +// ^^ meta.statement.loop.for.java meta.group.java +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ - keyword +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + for (; {} +// ^^^^^^^^^ - meta.statement.loop.for meta.statement.loop.for +// ^^^^ meta.statement.loop.for.java - meta.group +// ^^^ meta.statement.loop.for.java meta.group.java +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ - keyword +// ^ punctuation.section.group.begin.java +// ^ punctuation.terminator.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + for (;; {} +// ^^^^^^^^^^ - meta.statement.loop.for meta.statement.loop.for +// ^^^^ meta.statement.loop.for.java - meta.group +// ^^^^ meta.statement.loop.for.java meta.group.java +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ - keyword +// ^ punctuation.section.group.begin.java +// ^^ punctuation.terminator.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + for (;;;;) {;;;} +// ^^^^^^^^^^ - meta.statement.loop.for meta.statement.loop.for +// ^^^^ meta.statement.loop.for.java - meta.group +// ^^^^^^ meta.statement.loop.for.java meta.group.java +// ^ meta.statement.loop.for.java - meta.block meta.block meta.block +// ^^^^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ - keyword +// ^ punctuation.section.group.begin.java +// ^^ punctuation.terminator.java +// ^^ invalid.illegal.stray.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^^ punctuation.terminator.java +// ^ punctuation.section.block.end.java + + for (i = 0; i < 10; i += 2) {} +// ^^^^ meta.statement.loop.for.java +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java +// ^ meta.statement.loop.for.java - meta.block meta.block meta.block +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ punctuation.section.group.begin.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ variable.other.java +// ^^ keyword.operator.assignment.augmented.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + for (i = , =, , 0; < 10 &&; += 2) {} +// ^^^^ meta.statement.loop.for.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java +// ^ meta.statement.loop.for.java - meta.block meta.block meta.block +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ punctuation.section.group.begin.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ punctuation.separator.comma.java +// ^ keyword.operator.assignment.java +// ^ punctuation.separator.comma.java +// ^ punctuation.separator.comma.java +// ^ constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ keyword.operator.comparison.java +// ^^ constant.numeric.value.java +// ^^ keyword.operator.logical.java +// ^ punctuation.terminator.java +// ^^ keyword.operator.assignment.augmented.java +// ^ constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + for (i = 0, j = 0; i < 10 && j < 5; i += 2, ++j) {} +// ^^^^ meta.statement.loop.for.java - meta.statement.loop.for meta.statement.loop.for +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java - meta.statement.loop.for meta.statement.loop.for +// ^ meta.statement.loop.for.java - meta.block meta.block meta.block +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ punctuation.section.group.begin.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^^ keyword.operator.logical.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ variable.other.java +// ^^ keyword.operator.assignment.augmented.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java + + for (int i = 0; i < 10; i += 2) {} +// ^^^^ meta.statement.loop.for.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java +// ^ meta.statement.loop.for.java - meta.block meta.block meta.block +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ variable.other.java +// ^^ keyword.operator.assignment.augmented.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java + + for (int i = , =, , 0; < 10 &&; += 2) {} +// ^^^^ meta.statement.loop.for.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java +// ^ meta.statement.loop.for.java - meta.block meta.block meta.block +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ punctuation.separator.comma.java +// ^ keyword.operator.assignment.java +// ^ punctuation.separator.comma.java +// ^ punctuation.separator.comma.java +// ^ constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ keyword.operator.comparison.java +// ^^ constant.numeric.value.java +// ^^ keyword.operator.logical.java +// ^ punctuation.terminator.java +// ^^ keyword.operator.assignment.augmented.java +// ^ constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + for (int i = 0, j = 0; i < 10 && j < 5; i += 2, ++j) {} +// ^^^^ meta.statement.loop.for.java - meta.statement.loop.for meta.statement.loop.for +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java - meta.statement.loop.for meta.statement.loop.for +// ^ meta.statement.loop.for.java - meta.block meta.block meta.block +// ^^ meta.statement.loop.for.java meta.block.java +// ^^^ keyword.control.loop.for.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^^ keyword.operator.logical.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ variable.other.java +// ^^ keyword.operator.assignment.augmented.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java + + for (final int x = 10;;) {} +// ^^^^ meta.statement.loop.for.java - meta.statement.loop.for meta.statement.loop.for +// ^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java - meta.statement.loop.for meta.statement.loop.for +// ^^^ keyword.control.loop.for.java +// ^^^^^ storage.modifier.java +// ^^^ storage.type.primitive.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^^ punctuation.terminator.java +// ^ punctuation.section.group.end.java + + for (native int x = 10;;) {} +// ^^^^ meta.statement.loop.for.java - meta.statement.loop.for meta.statement.loop.for +// ^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java - meta.statement.loop.for meta.statement.loop.for +// ^^^ keyword.control.loop.for.java +// ^^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^ storage.type.primitive.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^^ punctuation.terminator.java +// ^ punctuation.section.group.end.java + + for (var i=0;i : new Bar[]) echo(iter); +// ^^^^ meta.statement.loop.for.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java +// ^^^^^^^^^^ meta.instantiation.java +// ^^ - meta.instantiation +// ^^^^^^^^^ meta.instantiation.java +// ^^^^^^^^^^ meta.statement.loop.for.java +// ^ - meta.statement.loop.for +// ^^^ keyword.control.loop.for.java +// ^ punctuation.section.group.begin.java +// ^^^^^ storage.modifier.java +// ^^^^^ meta.annotation.identifier.java +// ^^^^^ storage.type.class.java +// ^^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^^ variable.other.java +// ^ keyword.operator.ternary.java +// ^^^ keyword.other.storage.new.java +// ^^^ storage.type.class.java +// ^^ punctuation.section.generic.diamond.java +// ^ keyword.operator.ternary.java +// ^^^ keyword.other.storage.new.java +// ^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.group.end.java +// ^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + for (private @Anno var iter : cond ? new Foo<> : new Bar[]) echo(iter); +// ^^^^ meta.statement.loop.for.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.loop.for.java meta.group.java +// ^^^^^^^^^^ meta.instantiation.java +// ^^ - meta.instantiation +// ^^^^^^^^^ meta.instantiation.java +// ^^^^^^^^^^ meta.statement.loop.for.java +// ^ - meta.statement.loop.for +// ^^^ keyword.control.loop.for.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^^^ meta.annotation.identifier.java +// ^^^ storage.type.variant.java +// ^^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^^ variable.other.java +// ^ keyword.operator.ternary.java +// ^^^ keyword.other.storage.new.java +// ^^^ storage.type.class.java +// ^^ punctuation.section.generic.diamond.java +// ^ keyword.operator.ternary.java +// ^^^ keyword.other.storage.new.java +// ^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.group.end.java +// ^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + } +//^ meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java +} +//<- meta.class.java meta.block.java punctuation.section.block.end.java + + +/****************************************************************************** + * Break Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.15 + *****************************************************************************/ + +class BreakStatementTests { + + void run() { + + label: +// ^^^^^ entity.name.label.java +// ^ punctuation.separator.colon.java + + break$ ; +// ^^^^^^ variable.other.java - keyword + + $break ; +// ^^^^^^ variable.other.java - keyword + + break +// ^ - meta.statement.flow.break +// ^^^^^^ meta.statement.flow.break.java +// ^^^^^ keyword.control.flow.break.java + + break ; +// ^^^^^^^ meta.statement.flow.break.java +// ^ - meta.statement.flow.break +// ^^^^^ keyword.control.flow.break.java +// ^ punctuation.terminator.java + + break label; +// ^ - meta.statement.flow.break +// ^^^^^^^^^^^ meta.statement.flow.break.java +// ^ - meta.statement.flow.break +// ^^^^^ keyword.control.flow.break.java +// ^^^^^ variable.label.java +// ^ punctuation.terminator.java + + break +// ^ - meta.statement.flow.break +// ^^^^^^ meta.statement.flow.break.java +// ^^^^^ keyword.control.flow.break.java + label +// ^^^^^^^ meta.statement.flow.break.java +// ^^^^^ variable.label.java + ; +// ^ meta.statement.flow.break.java +// ^ - meta.statement.flow.break +// ^ punctuation.terminator.java + + break str + 5; +// ^ - meta.statement.flow.break +// ^^^^^^^^^^^^^ meta.statement.flow.break.java +// ^ - meta.statement.flow.break +// ^^^^^ keyword.control.flow.break.java +// ^^^ variable.label.java +// ^ invalid.illegal.expect-terminator.java +// ^ invalid.illegal.expect-terminator.java +// ^ punctuation.terminator.java + + break 5 + 5; +// ^ - meta.statement.flow.break +// ^^^^^^^^^^^ meta.statement.flow.break.java +// ^ - meta.statement.flow.break +// ^^^^^ keyword.control.flow.break.java +// ^ invalid.illegal.expect-terminator.java +// ^ invalid.illegal.expect-terminator.java +// ^ invalid.illegal.expect-terminator.java +// ^ punctuation.terminator.java + + goto label; +// ^^^^ invalid.illegal +// ^^^^^ variable.other.java + } +} + + +/****************************************************************************** + * Continue Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.16 + *****************************************************************************/ + +class ContinueStatementTests { + + void run() { + + label: +// ^^^^^ entity.name.label.java +// ^ punctuation.separator.colon.java + + continue$ ; +// ^^^^^^^^^ variable.other.java - keyword + + $continue ; +// ^^^^^^^^^ variable.other.java - keyword + + continue +// ^ - meta.statement.flow.continue +// ^^^^^^^^^ meta.statement.flow.continue.java +// ^^^^^^^^ keyword.control.flow.continue.java + + continue ; +// ^^^^^^^^^^ meta.statement.flow.continue.java +// ^ - meta.statement.flow.continue +// ^^^^^^^^ keyword.control.flow.continue.java +// ^ punctuation.terminator.java + + continue label; +// ^ - meta.statement.flow.continue +// ^^^^^^^^^^^^^^ meta.statement.flow.continue.java +// ^ - meta.statement.flow.continue +// ^^^^^^^^ keyword.control.flow.continue.java +// ^^^^^ variable.label.java +// ^ punctuation.terminator.java + + continue +// ^ - meta.statement.flow.continue +// ^^^^^^^^^ meta.statement.flow.continue.java +// ^^^^^^^^ keyword.control.flow.continue.java + label +// ^^^^^^^ meta.statement.flow.continue.java +// ^^^^^ variable.label.java + ; +// ^ meta.statement.flow.continue.java +// ^ - meta.statement.flow.continue +// ^ punctuation.terminator.java + + continue str + 5; +// ^ - meta.statement.flow.continue +// ^^^^^^^^^^^^^^^^ meta.statement.flow.continue.java +// ^ - meta.statement.flow.continue +// ^^^^^^^^ keyword.control.flow.continue.java +// ^^^ variable.label.java +// ^ invalid.illegal.expect-terminator.java +// ^ invalid.illegal.expect-terminator.java +// ^ punctuation.terminator.java + + continue 5 + 5; +// ^ - meta.statement.flow.continue +// ^^^^^^^^^^^^^^ meta.statement.flow.continue.java +// ^ - meta.statement.flow.continue +// ^^^^^^^^ keyword.control.flow.continue.java +// ^ invalid.illegal.expect-terminator.java +// ^ invalid.illegal.expect-terminator.java +// ^ invalid.illegal.expect-terminator.java +// ^ punctuation.terminator.java + } +} + + +/****************************************************************************** + * Return Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.17 + *****************************************************************************/ + +class ReturnStatementTests { + + void run() { + + return$ ; +// ^^^^^^^ variable.other.java - keyword + + $return ; +// ^^^^^^^ variable.other.java - keyword + + return +// ^ - meta.statement.flow.return - keyword +// ^^^^^^^ meta.statement.flow.return.java +// ^^^^^^ keyword.control.flow.return.java + + return; +// ^^^^^^^ meta.statement.flow.return.java +// ^ - meta.statement.flow.return +// ^^^^^^ keyword.control.flow.return.java +// ^ punctuation.terminator.java + + return variable +// ^ - meta.statement.flow.return - keyword +// ^^^^^^^^^^^^^^^^ meta.statement.flow.return.java +// ^^^^^^ keyword.control.flow.return.java +// ^^^^^^^^ variable.other.java + + return variable + func(10); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.flow.return.java +// ^ - meta.statement.flow.return +// ^^^^^^ keyword.control.flow.return.java +// ^^^^^^^^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + return +// ^ - meta.statement.flow.return - keyword +// ^^^^^^^ meta.statement.flow.return.java +// ^^^^^^ keyword.control.flow.return.java + variable +// ^^^^^^^^^^ meta.statement.flow.return.java +// ^^^^^^^^ variable.other.java + + +// ^^^ meta.statement.flow.return.java +// ^ keyword.operator.arithmetic.java + func +// ^^^^^^ meta.statement.flow.return.java +// ^^^^ variable.function.java + ( +// ^^^ meta.statement.flow.return.java +// ^ punctuation.section.group.begin.java + 10 +// ^^^^ meta.statement.flow.return.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java + ) +// ^^^ meta.statement.flow.return.java +// ^ punctuation.section.group.end.java + ; +// ^ meta.statement.flow.return.java +// ^ - meta.statement.flow.return +// ^ punctuation.terminator.java + + return new MyClass(); +// ^ - meta.statement.flow.return - keyword +// ^^^^^^^^^^^^^^^^^^^^ meta.statement.flow.return.java +// ^ - meta.statement.flow.return +// ^^^^^^ keyword.control.flow.return.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + return (a, int b) -> a + b; +// ^ - meta.statement.flow.return - keyword +// ^^^^^^^ meta.statement.flow.return.java - meta.function.anonymous - meta.group +// ^^^^^^^^^^ meta.statement.flow.return.java meta.function.anonymous.parameters.java meta.group.java +// ^^^^^^^^^ meta.statement.flow.return.java meta.function.anonymous.java - meta.group +// ^^^^^^ keyword.control.flow.return.java +// ^ punctuation.section.group.begin.java +// ^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^^ keyword.declaration.function.arrow.java +// ^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^ variable.other.java +// ^ punctuation.terminator.java + } +//^ meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java +} + + +/****************************************************************************** + * Throw Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.18 + *****************************************************************************/ + +class ThrowStatementTests { + + void run() { + + throw$ ; +// ^^^^^^ variable.other.java - keyword + + $throw ; +// ^^^^^^ variable.other.java - keyword + + throw +// ^ - meta.statement.flow.throw - keyword +// ^^^^^^ meta.statement.flow.throw.java +// ^^^^^ keyword.control.flow.throw.java + + throw; +// ^^^^^^ meta.statement.flow.throw.java +// ^ - meta.statement.flow.throw +// ^^^^^ keyword.control.flow.throw.java +// ^ punctuation.terminator.java + + throw variable +// ^ - meta.statement.flow.throw - keyword +// ^^^^^^^^^^^^^^^ meta.statement.flow.throw.java +// ^^^^^ keyword.control.flow.throw.java +// ^^^^^^^^ variable.other.java + + throw variable + func(10); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.flow.throw.java +// ^ - meta.statement.flow.throw +// ^^^^^ keyword.control.flow.throw.java +// ^^^^^^^^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + throw +// ^ - meta.statement.flow.throw - keyword +// ^^^^^^ meta.statement.flow.throw.java +// ^^^^^ keyword.control.flow.throw.java + variable +// ^^^^^^^^^^ meta.statement.flow.throw.java +// ^^^^^^^^ variable.other.java + + +// ^^^ meta.statement.flow.throw.java +// ^ keyword.operator.arithmetic.java + func +// ^^^^^^ meta.statement.flow.throw.java +// ^^^^ variable.function.java + ( +// ^^^ meta.statement.flow.throw.java +// ^ punctuation.section.group.begin.java + 10 +// ^^^^ meta.statement.flow.throw.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java + ) +// ^^^ meta.statement.flow.throw.java +// ^ punctuation.section.group.end.java + ; +// ^ meta.statement.flow.throw.java +// ^ - meta.statement.flow.throw +// ^ punctuation.terminator.java + + throw new MyClass(); +// ^ - meta.statement.flow.throw - keyword +// ^^^^^^^^^^^^^^^^^^^ meta.statement.flow.throw.java +// ^ - meta.statement.flow.throw +// ^^^^^ keyword.control.flow.throw.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + throw (a, int b) -> a + b; +// ^ - meta.statement.flow.throw - keyword +// ^^^^^^ meta.statement.flow.throw.java - meta.function.anonymous - meta.group +// ^^^^^^^^^^ meta.statement.flow.throw.java meta.function.anonymous.parameters.java meta.group.java +// ^^^^^^^^^ meta.statement.flow.throw.java meta.function.anonymous.java - meta.group +// ^^^^^ keyword.control.flow.throw.java +// ^ punctuation.section.group.begin.java +// ^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^^ keyword.declaration.function.arrow.java +// ^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^ variable.other.java +// ^ punctuation.terminator.java + } +//^ meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java +} + + +/****************************************************************************** + * Synchronized Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.19 + *****************************************************************************/ + +class SynchronizedStatementTests { + + + synchronized$ ; +//^^^^^^^^^^^^^ meta.field.type.java storage.type.class.java - keyword + + $synchronized ; +//^^^^^^^^^^^^^ meta.field.type.java storage.type.class.java - keyword + + synchronized +//^^^^^^^^^^^^^ meta.function.modifier.java +//^^^^^^^^^^^^ storage.modifier.java + + synchronized void synchronizedMethod() { +//^^^^^^^^^^^^^ meta.function.modifier.java +// ^^^^^ meta.function.return-type.java +// ^^^^^^^^^^^^^^^^^^ meta.function.identifier.java +// ^^ meta.function.parameters.java meta.group.java +// ^ meta.function.java +// ^^ meta.function.java meta.block.java +//^^^^^^^^^^^^ storage.modifier.java +// ^^^^ storage.type.void.java +// ^^^^^^^^^^^^^^^^^^ entity.name.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java + + synchronized$ ; +// ^^^^^^^^^^^^^ variable.other.java - keyword + + $synchronized ; +// ^^^^^^^^^^^^^ variable.other.java - keyword + + synchronized +// ^ - meta.statement.flow.synchronized - keyword +// ^^^^^^^^^^^^^ meta.statement.flow.synchronized.java +// ^^^^^^^^^^^^ keyword.control.flow.synchronized.java +// ^ - keyword + + synchronized () ; +//^^^^^^^^^^^^^^^^^^^ meta.statement.flow.synchronized.java +// ^^ meta.group.java +// ^ - meta.statement.flow.synchronized +// ^ - keyword +// ^^^^^^^^^^^^ keyword.control.flow.synchronized.java +// ^ - keyword +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + synchronized () {} +// ^ - meta.statement.flow.synchronized +// ^^^^^^^^^^^^^^^^^^ meta.statement.flow.synchronized.java +// ^^ meta.group.java +// ^^ meta.block.java +// ^ - meta.statement.flow.synchronized +// ^ - keyword +// ^^^^^^^^^^^^ keyword.control.flow.synchronized.java +// ^ - keyword +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + } +} + + +/****************************************************************************** + * Try Statement Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-14.html#jls-14.20 + *****************************************************************************/ + +class TryStatementTests { + + void testTry() { + + try$ ; +// ^^^^ variable.other.java - keyword + + $try ; +// ^^^^ variable.other.java - keyword + + try +// ^^^^ meta.statement.exception.try.java +// ^^^ keyword.control.exception.try.java + } + + void testCatch() { + + catch$ ; +// ^^^^^^ variable.other.java - keyword + + $catch ; +// ^^^^^^ variable.other.java - keyword + + catch +// ^^^^^^ meta.statement.exception.catch.java +// ^^^^^ keyword.control.exception.catch.java + + catch (int e) +// ^^^^^^^^^^^^^^^ meta.statement.exception.catch.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java + + catch (int[] e) +// ^^^^^^^^^^^^^^^ meta.statement.exception.catch.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^^ invalid.illegal.unexpected-modifier.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java + + catch (foo[] e) +// ^^^^^^^^^^^^^^^ meta.statement.exception.catch.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.class.java +// ^^ invalid.illegal.unexpected-modifier.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java + + catch (foo[] | bar[] | int e[]) +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.catch.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.class.java +// ^^ invalid.illegal.unexpected-modifier.java +// ^ punctuation.separator.pipe.java +// ^^^ storage.type.class.java +// ^^ invalid.illegal.unexpected-modifier.java +// ^ punctuation.separator.pipe.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ variable.other.java +// ^^ invalid.illegal.unexpected-modifier.java +// ^ punctuation.section.group.end.java + + catch (5 + 10) +// ^^^^^^^^^^^^^^ meta.statement.exception.catch.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^ invalid.illegal.unexpected-token.java +// ^ invalid.illegal.unexpected-token.java +// ^^ invalid.illegal.unexpected-token.java +// ^ punctuation.section.group.end.java + } + + void testFinally() { + + finally$ ; +// ^^^^^^^^ variable.other.java - keyword + + $finally ; +// ^^^^^^^^ variable.other.java - keyword + + finally +// ^^^^^^^^ meta.statement.exception.finally.java +// ^^^^^^^ keyword.control.exception.finally.java + } + + void testSimleTryCatchFinally() { + + // ensure not to break highlighting even though braces are missing + try foo() catch (Exception e) bar(e) finally baz() +// ^^^^^^^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try - meta.statement.exception.catch - meta.statement.exception.finally +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.statement.exception.catch meta.statement.exception.catch - meta.statement.exception.finally - meta.statement.exception.try +// ^^^^^^ meta.statement.exception.catch.java - meta.group +// ^^^^^^^^^^^^^ meta.statement.exception.catch.java meta.group.java +// ^^^^ meta.statement.exception.catch.java - meta.group +// ^^^ meta.statement.exception.catch.java meta.group.java +// ^ meta.statement.exception.catch.java - meta.group +// ^^^^^^^^^^^^^ meta.statement.exception.finally.java - meta.statement.exception.finally meta.statement.exception.finally - meta.statement.exception.catch - meta.statement.exception.try +// ^^^ keyword.control.exception.try.java +// ^^^ variable.function.java +// ^^^^^ keyword.control.exception.catch.java +// ^^^ variable.function.java +// ^^^^^^^ keyword.control.exception.finally.java +// ^^^ variable.function.java + + try { foo(); } catch (Exception e) { bar(e); } finally { baz(); } +// ^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.block - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^^^^^ meta.statement.exception.try.java meta.block.java - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^^^^^^^^^^^^ meta.statement.exception.catch.java meta.group.java - meta.statement.exception.catch meta.statement.exception.catch +// ^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^^^^^^^^^^ meta.statement.exception.catch.java meta.block.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^^^^^^^ meta.statement.exception.finally.java - meta.statement.exception.finally meta.statement.exception.finally +// ^^^^^^^^^^ meta.statement.exception.finally.java meta.block.java - meta.statement.exception.finally meta.statement.exception.finally +// ^^^ keyword.control.exception.try.java +// ^^^ variable.function.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^ storage.type.class.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^^^ variable.function.java +// ^ punctuation.section.block.end.java +// ^^^^^^^ keyword.control.exception.finally.java +// ^ punctuation.section.block.begin.java +// ^^^ variable.function.java +// ^ punctuation.section.block.end.java + + try { +// ^^^^ meta.block.java meta.statement.exception.try.java +// ^ meta.statement.exception.try.java meta.block.java +// ^^^ keyword.control.exception.try.java +// ^ punctuation.section.block.begin.java + foo(); + } catch (Exception e) { +// ^ meta.statement.exception.try.java meta.block.java +// ^ - meta.statement.exception.try - meta.statement.exception.catch - meta.statement.exception.finally +// ^^^^^^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^^^^^^^^^^^^ meta.statement.exception.catch.java meta.group.java - meta.statement.exception.catch meta.statement.exception.catch +// ^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^ meta.statement.exception.catch.java meta.block.java - meta.statement.exception.catch meta.statement.exception.catch +// ^ punctuation.section.block.end.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^ storage.type.class.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java + bar(e); + } finally { +// ^ meta.statement.exception.catch.java meta.block.java +// ^ - meta.statement.exception.try - meta.statement.exception.catch - meta.statement.exception.finally +// ^^^^^^^^ meta.statement.exception.finally.java - meta.statement.exception.finally meta.statement.exception.finally +// ^^ meta.statement.exception.finally.java meta.block.java - meta.statement.exception.finally meta.statement.exception.finally +// ^ punctuation.section.block.end.java +// ^^^^^^^ keyword.control.exception.finally.java +// ^ punctuation.section.block.begin.java + baz(); + } +// ^ meta.statement.exception.finally.java meta.block.java punctuation.section.block.end.java +// ^ - meta.statement.exception.try - meta.statement.exception.catch - meta.statement.exception.finally + } + + void testTryCatchFinallyWithResource() { + + try (, , = , = null ; , =) {} catch ( | | ) {} +// ^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.try.java meta.group.java - meta.statement.exception.try meta.statement.exception.try +// ^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try - meta.group +// ^^ meta.statement.exception.try.java meta.block.java +// ^ - meta.statement.exception.try +// ^^^^^^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.group +// ^^^^^^^ meta.statement.exception.catch.java meta.group.java +// ^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.group - meta.statement.exception.catch meta.block +// ^^ meta.statement.exception.catch.java meta.block.java +// ^ - meta.statement.exception.catch +// ^^^ keyword.control.exception.try.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.separator.comma.java +// ^ punctuation.separator.comma.java +// ^ keyword.operator.assignment.java +// ^ punctuation.separator.comma.java +// ^ keyword.operator.assignment.java +// ^^^^ constant.language.null.java +// ^ punctuation.terminator.java +// ^ punctuation.separator.comma.java +// ^ keyword.operator.assignment.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.separator.pipe.java +// ^ punctuation.separator.pipe.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + try (foo = Bar.baz(path)) {} +// ^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.try.java meta.group.java - meta.statement.exception.try meta.statement.exception.try +// ^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try - meta.group +// ^^ meta.statement.exception.try.java meta.block.java +// ^^^ keyword.control.exception.try.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^ variable.other.java +// ^^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + try (foo[], []) {} +// ^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^^^^^^ meta.statement.exception.try.java meta.group.java - meta.statement.exception.try meta.statement.exception.try +// ^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try - meta.group +// ^^ meta.statement.exception.try.java meta.block.java +// ^^^ keyword.control.exception.try.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^^ storage.modifier.array.java +// ^ punctuation.separator.comma.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + try (foo[] bar[], []) {} +// ^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^^^^^^^^^^^^ meta.statement.exception.try.java meta.group.java - meta.statement.exception.try meta.statement.exception.try +// ^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try - meta.group +// ^^ meta.statement.exception.try.java meta.block.java +// ^^^ keyword.control.exception.try.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.class.java +// ^^ storage.modifier.array.java +// ^^^ variable.other.java +// ^^ storage.modifier.array.java +// ^ punctuation.separator.comma.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + try (Stream lines = Files.lines(path)) { +// ^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.try.java meta.group.java - meta.statement.exception.try meta.statement.exception.try +// ^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try - meta.group +// ^^ meta.statement.exception.try.java meta.block.java +// ^^^ keyword.control.exception.try.java +// ^ punctuation.section.group.begin.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^ variable.other.java +// ^^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java + + } catch (IOException ignore) { +//^^^ meta.statement.exception.try.java meta.block.java +// ^ - meta.statement.exception.try - meta.statement.exception.catch +// ^^^^^^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.catch.java meta.group.java - meta.statement.exception.catch meta.statement.exception.catch +// ^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^ meta.statement.exception.catch.java meta.block.java +// ^ punctuation.section.block.end.java +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^ storage.type.class.java +// ^^^^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java + } catch (final MyException | com.net.org.Foo.Bar | +//^^^ meta.statement.exception.catch.java meta.block.java +// ^ - meta.statement.exception.catch +// ^^^^^^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.catch.java meta.group.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^^^^ keyword.control.exception.catch.java +// ^ punctuation.section.group.begin +// ^^^^^ storage.modifier.java +// ^^^^^^^^^^^ storage.type.class +// ^ punctuation.separator.pipe.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^ punctuation.separator.pipe.java + YourException +// ^^^^^^^^^^^^^^^ meta.statement.exception.catch.java meta.group.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^^^^^^^^^^^^ storage.type.class.java + ignore) {} +// ^^^^^^^ meta.statement.exception.catch.java meta.group.java - meta.statement.exception.catch meta.statement.exception.catch +// ^ meta.statement.exception.catch.java - meta.statement.exception.catch meta.statement.exception.catch +// ^^ meta.statement.exception.catch.java meta.block.java +// ^^^^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java + + try (final InputStream is = new FileInputStream(args[0]); +// ^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.try.java meta.group.java - meta.statement.exception.try meta.statement.exception.try +// ^^^ keyword.control.exception.try.java +// ^ punctuation.section.group.begin.java +// ^^^^^ storage.modifier.java +// ^^^^^^^^^^^ storage.type.class.java +// ^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^^ variable.other.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + final OutputStream os = new FileOutputStream(args[1])) { +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.try.java meta.group.java - meta.statement.exception.try meta.statement.exception.try +// ^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try - meta.group +// ^^ meta.statement.exception.try.java meta.block.java +// ^^^^^ storage.modifier.java +// ^^^^^^^^^^^^ storage.type.class.java +// ^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^^ variable.other.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java + } +// ^ meta.statement.exception.try.java meta.block.java punctuation.section.block.end.java +// ^ - meta.statement.exception.try + + try (var in = new BufferedReader()) { +// ^^^^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.statement.exception.try.java meta.group.java - meta.statement.exception.try meta.statement.exception.try +// ^ meta.statement.exception.try.java - meta.statement.exception.try meta.statement.exception.try - meta.group +// ^^ meta.statement.exception.try.java meta.block.java +// ^^^ storage.type.variant.java +// ^^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^^^^^^ storage.type.class.java + var line = in.readLine(); +// ^^^ storage.type.variant.java +// ^^^^ variable.other.java +// ^ keyword.operator.assignment.java + } +// ^ meta.statement.exception.try.java meta.block.java punctuation.section.block.end.java +// ^ - meta.statement.exception.try + } +} + + +/****************************************************************************** + * Method Invocation Expressions Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.2 + *****************************************************************************/ + +class MethodInvocationExpressionsTests { + + void invokeMethods() { + + Foo(); +// ^^^ - variable.function.java + + foo( ; +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.terminator.java + + foo(); +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + foo (); +// ^^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + foo +// ^^^^ meta.function-call.identifier.java +// ^^^ variable.function.java + () ; +//^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + object.foo(); +// ^^^^^^ variable.other.java +// ^ punctuation.accessor.dot.java +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + super.foo(); +// ^^^^^ variable.language.super.java +// ^ punctuation.accessor.dot.java +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + super.foo(); +// ^^^^^ variable.language.super.java +// ^ punctuation.accessor.dot.java +// ^^^ meta.generic.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + this.foo(); +// ^^^^ variable.language.this.java +// ^ punctuation.accessor.dot.java +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + this.foo(); +// ^^^^ variable.language.this.java +// ^ punctuation.accessor.dot.java +// ^^^ meta.generic.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + this. foo(); +// ^^^^ variable.language.this.java +// ^ punctuation.accessor.dot.java +// ^^^ meta.generic.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + ( foo ).bar(); +// ^^^^^^^ meta.group.java +// ^^^^ - meta.group +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^ - meta.function-call - meta.group +// ^ punctuation.accessor.dot.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + ( foo .bar(); +// ^^^^^^^^^^^^ meta.group.java +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java +// ^ - meta.function-call - meta.group +// ^ punctuation.accessor.dot.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + foo.bar(hello(world); +// ^^^^^^ meta.group.java - meta.group meta.group +// ^^^^^^^ meta.group.java meta.group.java +// ^^^ meta.function-call.identifier.java - meta.function-call meta.function-call +// ^ meta.function-call.arguments.java - meta.function-call meta.function-call +// ^^^^^ meta.function-call.arguments.java meta.function-call.identifier.java +// ^^^^^^^ meta.function-call.arguments.java meta.function-call.arguments.java +// ^ - meta.function-call - meta.group +// ^ punctuation.accessor.dot.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + some.other.path. +// ^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java + foo.MyClass.staticMethod(true); +// ^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^^^^ meta.function-call.identifier.java +// ^^^^^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + some.other.path +// ^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java + .foo.MyClass.staticMethod(true); +// ^^^^^^^^^^^^ meta.path.java +// ^^^^^^^^^^^^ meta.function-call.identifier.java +// ^^^^^^ meta.function-call.arguments.java meta.group.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + } +//^ meta.function.java punctuation.section.block.end.java +} +// <- punctuation.section.block.end.java + + +/****************************************************************************** + * Instance Creation Expressions Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.9 + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.10 + *****************************************************************************/ + +class InstanceCreationExpressionsTests { + + @SyntaxTest + public void instantiateClassesObjects() { + + new$ ; +// ^^^^ variable.other.java - keyword + + $new ; +// ^^^^ variable.other.java - keyword + + new TestClass ; +// ^^^^^^^^^^^^^^ meta.instantiation.java +// ^^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.terminator.java + + new TestClass( +// ^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^ meta.group.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java + + new TestClass( ; +// ^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^ meta.group.java +// ^^ - meta.instantiation - meta.group +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.terminator.java + + new TestClass(foo ; +// ^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^ meta.group.java +// ^^ - meta.instantiation - meta.group +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.terminator.java + + new TestClass(foo); +// ^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^ meta.group.java +// ^^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new testclass(foo); +// ^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^ meta.group.java +// ^^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java + + new @Foo TestClass(foo); +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^^ - meta.annotation +// ^^^^^ meta.group.java +// ^^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^ variable.annotation.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java + + new @foo testclass(foo); +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^^ - meta.annotation +// ^^^^^ meta.group.java +// ^^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^ variable.annotation.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java + + new com.java.TestClass(foo); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ storage.type.class.java +// ^^^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java + + new com.java.testclass(foo); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ storage.type.class.java +// ^^^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java + + new OuterClass.InnerClass(); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^ storage.type.class.java + + new @Foo com . @Foo java . @Foo OuterClass . @Foo InnerClass(foo); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^ - meta.annotation +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^^ - meta.annotation +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^ - meta.annotation +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^^^ - meta.annotation +// ^^^ keyword.other.storage.new.java +// ^ punctuation.definition.annotation.java +// ^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^ variable.annotation.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^ variable.annotation.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^ variable.annotation.java +// ^^^^^^^^^^ storage.type.class.java +// ^^^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java + + new @foo com . @foo java . @foo outerclass . @foo innerclass(foo) { }; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java - meta.block meta.block meta.block +// ^^^ meta.instantiation.java meta.class.java meta.block.java +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^ - meta.annotation +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.path.java +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^^ - meta.annotation +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^ - meta.annotation +// ^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^^^ - meta.annotation +// ^^^ keyword.other.storage.new.java +// ^ punctuation.definition.annotation.java +// ^^^ variable.annotation.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^ variable.annotation.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^ variable.annotation.java +// ^^^^^^^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.definition.annotation.java +// ^^^ variable.annotation.java +// ^^^^^^^^^^ storage.type.class.java +// ^^^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + + new SubClass(new SubClass[0], true); +// ^^^^^^^^^^^^^ meta.instantiation.java - meta.instantiation meta.instantiation +// ^^^^^^^^^^^^^^^ meta.instantiation.java meta.instantiation.java +// ^^^^^^^ meta.instantiation.java - meta.instantiation meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^ storage.type.class.java +// ^^^ meta.brackets.java +// ^ punctuation.separator.comma.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new var(); +// ^^^^^^^^^ meta.instantiation.java +// ^^^ keyword.other.storage.new.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new static LocalClass() {}; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + + new class LocalClass() {}; +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^ keyword.other.storage.new.java +// ^^^^^ invalid.illegal.unexpected-keyword.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + + new if (foo == true) {}; +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^ keyword.other.storage.new.java +// ^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^^ keyword.operator.comparison.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.block.begin.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + } + + @SyntaxTest + public void instantiatePrimitiveArrays() { + + new int[]{0, 0, 0}; +// ^ - meta.instantiation +// ^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.braces.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.braces.end.java + + new byte[size]; +// ^ - meta.instantiation +// ^^^^^^^^^^^^^^ meta.instantiation.java +// ^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^^ storage.type.primitive.java + + new int[][][] { +// ^^^^^^^^^^^^^^ meta.instantiation.java - meta.braces +// ^^ meta.instantiation.java meta.braces.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.braces.begin.java + { { 1, 2 }, { 3, 4 } }, +// ^^ meta.instantiation.java meta.braces.java meta.braces.java - meta.braces meta.braces meta.braces +// ^^^^^^^^ meta.instantiation.java meta.braces.java meta.braces.java meta.braces.java +// ^^ meta.instantiation.java meta.braces.java meta.braces.java - meta.braces meta.braces meta.braces +// ^^^^^^^^ meta.instantiation.java meta.braces.java meta.braces.java meta.braces.java +// ^^ meta.instantiation.java meta.braces.java meta.braces.java - meta.braces meta.braces meta.braces +// ^ meta.instantiation.java meta.braces.java - meta.braces meta.braces +// ^ punctuation.section.braces.begin.java +// ^ punctuation.section.braces.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.separator.comma.java +// ^ punctuation.section.braces.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.separator.comma.java + { { 5, 6 }, { 7, 8 } } +// ^^ meta.instantiation.java meta.braces.java meta.braces.java - meta.braces meta.braces meta.braces +// ^^^^^^^^ meta.instantiation.java meta.braces.java meta.braces.java meta.braces.java +// ^^ meta.instantiation.java meta.braces.java meta.braces.java - meta.braces meta.braces meta.braces +// ^^^^^^^^ meta.instantiation.java meta.braces.java meta.braces.java meta.braces.java +// ^^ meta.instantiation.java meta.braces.java meta.braces.java - meta.braces meta.braces meta.braces +// ^ meta.instantiation.java meta.braces.java - meta.braces meta.braces +// ^ punctuation.section.braces.begin.java +// ^ punctuation.section.braces.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.separator.comma.java +// ^ punctuation.section.braces.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.separator.comma.java +// ^ constant.numeric.value.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.section.braces.end.java + }; +// ^^ meta.instantiation.java meta.braces.java +// ^ - meta.instantiation - meta.braces +// ^ punctuation.section.braces.end.java +// ^ punctuation.terminator.java + + new int[1][3][4]; +// ^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^^^^^ meta.brackets.java +// ^ - meta.instantiation - meta.brackets +// ^^^ storage.type.primitive.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java + } + + + @SyntaxTest + public void instantiateObjectArrays() { + + new String[] {"foo", "bar"}; +// ^^^^^^^^^^^^^ meta.instantiation.java - meta.braces +// ^^^^^^^^^^^^^^ meta.instantiation.java meta.braces.java +// ^ - meta.instantiation - meta.braces +// ^^^ keyword.other.storage.new.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.braces.begin.java +// ^^^^^ string.quoted.double.java +// ^ punctuation.separator.comma.java +// ^^^^^ string.quoted.double.java +// ^ punctuation.section.braces.end.java +// ^ punctuation.terminator.java + + new String[]() {"foo", "bar"}; +// ^^^^^^^^^^^^ meta.instantiation.java - meta.braces +// ^^^^^^^^^^^^^^^^^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.block.begin.java +// ^^^^^ string.quoted.double.java +// ^ punctuation.separator.comma.java +// ^^^^^ string.quoted.double.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + + new MyObject[1]; +// ^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^ meta.brackets +// ^ - meta.instantiation - meta.brackets +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.terminator.java + + new myobject[1]; +// ^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^ meta.brackets +// ^ - meta.instantiation - meta.brackets +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.terminator.java + + new MyObject[1][]; +// ^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^ meta.brackets +// ^ - meta.instantiation - meta.brackets +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.terminator.java + + new @notnull MyObject @bound [size + 10] @anno []; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^^^^ meta.annotation.identifier.java +// ^ - meta.annotation +// ^^^^^^ meta.annotation.identifier.java +// ^ - meta.annotation +// ^^^^^^^^^^^ meta.brackets.java +// ^^^^^ meta.annotation.identifier.java +// ^ - meta.annotation +// ^^ meta.brackets.java +// ^ - meta.instantiation - meta.brackets +// ^^^ keyword.other.storage.new.java +// ^ punctuation.definition.annotation.java +// ^^^^^^^ variable.annotation.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.definition.annotation.java +// ^^^^^ variable.annotation.java +// ^ punctuation.section.brackets.begin.java +// ^^^^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.terminator.java + + new @notnull myobject @bound [size + 10] @anno []; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^^^^ meta.annotation.identifier.java +// ^ - meta.annotation +// ^^^^^^ meta.annotation.identifier.java +// ^ - meta.annotation +// ^^^^^^^^^^^ meta.brackets.java +// ^^^^^ meta.annotation.identifier.java +// ^ - meta.annotation +// ^^ meta.brackets.java +// ^ - meta.instantiation - meta.brackets +// ^^^ keyword.other.storage.new.java +// ^ punctuation.definition.annotation.java +// ^^^^^^^ variable.annotation.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.definition.annotation.java +// ^^^^^ variable.annotation.java +// ^ punctuation.section.brackets.begin.java +// ^^^^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.terminator.java + + new some.path.to.MyObject[3]; +// ^^^^ meta.instantiation.java - meta.path +// ^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java meta.path.java +// ^^^ meta.instantiation.java meta.brackets.java - meta.path +// ^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java + + new some.path.to.myobject[3]; +// ^^^^ meta.instantiation.java - meta.path +// ^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java meta.path.java +// ^^^ meta.instantiation.java meta.brackets.java - meta.path +// ^ - meta.instantiation +// ^^^ keyword.other.storage.new.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.brackets.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.brackets.end.java + } + + @SyntaxTest + public void instantiateGenericClassObjects() { + + new Generic<>; +// ^^^^^^^^^^^^^ meta.instantiation.java +// ^^ meta.generic.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^^ punctuation.section.generic.diamond.java +// ^ punctuation.terminator.java + + new Generic<>(); +// ^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^ meta.generic.java +// ^^ meta.group.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^^ punctuation.section.generic.diamond.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new Generic(); +// ^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^^ meta.generic.java +// ^^ meta.group.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new Generic<@Anno Type>(); +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^^^^^^^^ meta.generic.java +// ^^^^^ meta.annotation.identifier.java +// ^ - meta.annotation +// ^^ meta.group.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new Generic(); +// ^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^ meta.generic.java +// ^^ meta.group.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new @Anno Generic<@Anno ?>(); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java +// ^^^^^ meta.annotation.identifier.java +// ^^^^^^^^^ - meta.annotation +// ^^^^^^^^^ meta.generic.java +// ^^^^^ meta.annotation.identifier.java +// ^^^ - meta.annotation +// ^^ meta.group.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ variable.language.wildcard.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new Generic(); +// ^^^^^^^^^^^ meta.instantiation.java - meta.generic +// ^^^^^^^^^^^^^^^^ meta.instantiation.java meta.generic.java +// ^^ meta.instantiation.java meta.group.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new @Anno Generic<@Anno ? extends @Anno Type>(); +// ^^^^^^^^^^^^^^^^^ meta.instantiation.java - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java meta.generic.java +// ^^ meta.instantiation.java meta.group.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ variable.language.wildcard.java +// ^^^^^^^ storage.modifier.extends.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new @anno generic<@anno ? extends @anno type>(); +// ^^^^^^^^^^^^^^^^^ meta.instantiation.java - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java meta.generic.java +// ^^ meta.instantiation.java meta.group.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^ variable.language.wildcard.java +// ^^^^^^^ storage.modifier.extends.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new Generic(); +// ^^^^^^^^^^^ meta.instantiation.java - meta.generic +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java meta.generic.java +// ^^ meta.instantiation.java meta.group.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^^^ storage.modifier.extends.java +// ^^^^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new Generic(); +// ^^^^^^^^^^^ meta.instantiation.java - meta.generic +// ^^^^^^^^^^^^^^ meta.instantiation.java meta.generic.java +// ^^ meta.instantiation.java meta.group.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^^^^^ keyword.declaration.super.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new Generic(); +// ^^^ invalid.illegal.unexpected-keyword.java + + new Generic(); +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java + + new Generic(); +// ^^^ storage.type.primitive.java +// ^^^^^ meta.annotation.identifier.java +// ^^^^ - meta.annotation +// ^^ storage.modifier.array.java + + new Generic(); +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^^^ - meta.annotation meta.annotation +// ^^^^^ meta.annotation.parameters.java meta.annotation.identifier.java +// ^^^^^^ - meta.annotation meta.annotation +// ^^^^^^^^^^^^ meta.annotation.identifier.java - meta.path +// ^^^^^^^^^^^^^ meta.annotation.parameters.java meta.group.java +// ^^ storage.modifier.array.java + + new Generic(); +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^^^^^^^^^^ meta.annotation.identifier.java meta.path.java +// ^ meta.annotation.identifier.java - meta.path +// ^^^^^^^^^^^^^ meta.annotation.parameters.java meta.group.java +// ^^ storage.modifier.array.java + + new generic(); +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^ meta.annotation.identifier.java meta.path.java +// ^ meta.annotation.identifier.java - meta.path +// ^^^^^^^^^^^^^ meta.annotation.parameters.java meta.group.java +// ^^ storage.modifier.array.java + + new Generic(); +// ^^^^^^ storage.type.class.java +// ^^^ invalid.illegal.unexpected-keyword.java + + new Generic(); +// ^^^^^^^^^^^^ meta.generic.java +// ^^^^^^^^^^ meta.path.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java + + new generic(); +// ^^^^^^^^^^^^ meta.generic.java +// ^^^^^^^^^^ meta.path.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java + + new generic[] { new generic(1), new generic(2) }; +// ^^^^^^^^^^^^^^^^^ meta.instantiation.java - meta.braces - meta.instantiation meta.instantiation +// ^^ meta.instantiation.java meta.braces.java - meta.instantiation meta.instantiation +// ^^^^^^^^^^^^^^ meta.instantiation.java meta.braces.java meta.instantiation.java +// ^^ meta.instantiation.java meta.braces.java - meta.instantiation meta.instantiation +// ^^^^^^^^^^^^^^^ meta.instantiation.java meta.braces.java meta.instantiation.java +// ^ meta.instantiation.java meta.braces.java - meta.instantiation meta.instantiation +// ^ - meta.instantiation - meta.braces +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^^^ meta.generic.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.braces.begin +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.separator.comma.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.braces.end + + new ArrayList[] { new ArrayList(), new ArrayList() } +// ^^^^^^^^^^^^^^^^^^^ meta.instantiation.java - meta.braces - meta.instantiation meta.instantiation +// ^^ meta.instantiation.java meta.braces.java - meta.instantiation meta.instantiation +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java meta.braces.java meta.instantiation.java +// ^^ meta.instantiation.java meta.braces.java - meta.instantiation meta.instantiation +// ^^^^^^^^^^^^^^^^^^^^^^ meta.instantiation.java meta.braces.java meta.instantiation.java +// ^ meta.instantiation.java meta.braces.java - meta.instantiation meta.instantiation +// ^ - meta.instantiation - meta.braces +// ^^^ meta.generic.java +// ^^^^^^^^^^^^^^^ meta.generic.java +// ^^^^^^^^^^^^^ meta.path.java +// ^^^^^^ meta.generic.java - meta.path +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ variable.language.wildcard.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.brackets.begin.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.braces.begin.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.separator.comma.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.braces.end.java + + new +// ^^^^ meta.instantiation.java - meta.path +// ^^^ keyword.other.storage.new.java + a +// ^ meta.instantiation.java - meta.path +// ^^ meta.instantiation.java meta.path.java - meta.path meta.path +// ^ variable.namespace.java + . +// ^^^ meta.instantiation.java meta.path.java +// ^ punctuation.accessor.dot.java + b.Generic +// ^^^^^^^^^^^ meta.instantiation.java meta.path.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ storage.type.class.java + < +// ^ meta.instantiation.java meta.path.java - meta.generic +// ^^ meta.instantiation.java meta.path.java meta.generic.java +// ^ punctuation.section.generic.begin.java + a +// ^ meta.instantiation.java meta.path.java meta.generic.java - meta.path meta.path - variable +// ^ meta.instantiation.java meta.path.java meta.generic.java meta.path.java variable.namespace.java +// ^ meta.instantiation.java meta.path.java meta.generic.java meta.path.java - variable + . +// ^^^ meta.instantiation.java meta.path.java meta.generic.java meta.path.java +// ^ punctuation.accessor.dot.java + b.Generic +// ^^^^^^^^^^^ meta.instantiation.java meta.path.java meta.generic.java meta.path.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^ storage.type.class.java + >(); +//<- meta.instantiation.java meta.path.java meta.generic.java - meta.path meta.path +// ^^ meta.instantiation.java meta.path.java meta.generic.java - meta.path meta.path +// ^^ meta.instantiation.java meta.group.java - meta.path +// ^ - meta.instantiation +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + new Generic(); + + } +} + + +/****************************************************************************** + * Method Reference Expressions Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.13 + *****************************************************************************/ + +class MethodReferenceExpressionsTests { + + void run() { + + System::currentTimeMillis // static method +// ^^^^^^ storage.type.class.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^^^^^^^^^^^^ variable.function.reference.java + + List::size // inferred type arguments for generic type +// ^^^^ storage.type.class.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^ variable.function.reference.java + + List::size // explicit type arguments for generic type +// ^^^^ storage.type.class.java +// ^^^^^^^^ meta.generic.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^ variable.function.reference.java + + int[]::clone +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^ variable.function.reference.java + + T::tvarMember +// ^ storage.type.class.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^^^^^ variable.function.reference.java + + System.out::println +// ^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^ variable.other.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^^ variable.function.reference.java + + "abc"::length +// ^^^^^ string.quoted.double.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^ variable.function.reference.java + + foo[x]::bar +// ^^^ meta.variable.identifier.java variable.other.java +// ^^^ meta.variable.item-access.java meta.brackets.java +// ^^ punctuation.accessor.double-colon.java +// ^^^ variable.function.reference.java + + (test ? list.replaceAll(String::trim) : list) :: iterator +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.java +// ^^^^^^^^^^ meta.function-call.identifier.java +// ^^^^^^^^^^^^^^ meta.function-call.arguments.java meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^^ variable.other.java +// ^ keyword.operator.ternary.java +// ^^^^ variable.other.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^ variable.function.java +// ^^^^^^ storage.type.class.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^ variable.function.reference.java +// ^ keyword.operator.ternary.java +// ^^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^^^ variable.function.reference.java + + super::toString +// ^^^^^ variable.language.super.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^^^ variable.function.reference.java + + Arrays::sort // explicit type arguments +// ^^^^^^ storage.type.class.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^^^ meta.generic.java +// ^^^^ variable.function.reference.java + + ArrayList::new // constructor for parameterized type +// ^^^^^^^^^ storage.type.class.java +// ^^^^^^^^ meta.generic.java +// ^^ punctuation.accessor.double-colon.java +// ^^^ keyword.other.storage.new.java + + ArrayListnew // explicit type arguments for generic constructor +// ^^^ storage.type.class.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^^^^ meta.generic.java +// ^^^ keyword.other.storage.new.java + + Bar::new // generic class, generic constructor +// ^^^ storage.type.class.java +// ^^^^^^^^ meta.generic.java +// ^^ punctuation.accessor.double-colon.java +// ^^^^^^^^^ meta.generic.java +// ^^^ keyword.other.storage.new.java + + Outer.Inner::new // inner class constructor +// ^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^ storage.type.class.java +// ^^ punctuation.accessor.double-colon.java +// ^^^ keyword.other.storage.new.java + int[]::new // array creation +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^^ punctuation.accessor.double-colon.java +// ^^^ keyword.other.storage.new.java + } +} + + +/****************************************************************************** + * Cast Expressions Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.16 + *****************************************************************************/ + +class CastExpressionsTests { + + void primitiveTypeCastExpression() { + + () foo; +// ^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (int) foo; +// ^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (int$) foo; +// ^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (int) foo[10]; +// ^^^^^ meta.cast.java meta.group.java +// ^^^^^^^^ - meta.cast - meta.group +// ^^^ meta.variable.identifier.java +// ^^^^ meta.variable.item-access.java meta.brackets.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (int) foo(); +// ^^^^^ meta.cast.java meta.group.java +// ^ - meta.function-call - meta.cast - meta.group +// ^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + (int) foo -> {return 0}; +// ^^^^^ meta.cast.java meta.group.java +// ^ - meta.function.anonymous - meta.cast - meta.group +// ^^^ meta.function.anonymous.parameters.java +// ^^^^^^^^^^^^^^ meta.function.anonymous.java +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java +// ^ punctuation.section.block.begin.java +// ^^^^^^ keyword.control.flow.return.java +// ^ constant.numeric.value.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + + (int) this; +// ^^^^^ meta.cast.java meta.group.java +// ^^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^^^^ variable.language.this.java +// ^ punctuation.terminator.java + + (int) super.class; +// ^^^^^ meta.cast.java meta.group.java +// ^^^^^^^^^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^^^^^ variable.language.super.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java +// ^ punctuation.terminator.java + + (int) TestClass; +// ^^^^^ meta.cast.java meta.group.java +// ^^^^^^^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.terminator.java + + (int) new TestClass(); +// ^^^^^ meta.cast.java meta.group.java +// ^ - meta.cast - meta.group - meta.instantiation +// ^^^^^^^^^^^^^^^ meta.instantiation.java - meta.cast +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + (int) (char) (foo + 10); +// ^^^^^ meta.cast.java meta.group.java +// ^ - meta.cast - meta.group +// ^^^^^^ meta.cast.java meta.group.java +// ^ - meta.cast - meta.group +// ^^^^^^^^^^ meta.group.java - meta.cast +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^ punctuation.section.group.begin.java +// ^^^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^^ constant.numeric.value.java +// ^ punctuation.section.group.end.java + + (int[]) foo; +// ^^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (int[]) ! foo; +// ^^^^^^^ meta.cast.java meta.group.java +// ^^^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^ keyword.operator.logical.java +// ^^^ variable.other.java + + (int[]) ~ foo; +// ^^^^^^^ meta.cast.java meta.group.java +// ^^^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^ keyword.operator.bitwise.java +// ^^^ variable.other.java + + (var) foo; +// ^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^ invalid.illegal.unexpected-keyword.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + } + + void classTypeCastExpression() { + + (TestClass) foo; +// ^^^^^^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (TestClass[]) foo; +// ^^^^^^^^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^ storage.type.class.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (testclass) foo; +// ^^^^^^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (testclass[]) foo; +// ^^^^^^^^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^ storage.type.class.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (TestClass & OtherClass) foo; +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^ storage.type.class.java +// ^ keyword.operator.logical.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (testclass & otherclass) foo; +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^ storage.type.class.java +// ^ keyword.operator.logical.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (@anno testclass & @anno otherclass) foo; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.cast.java meta.group.java +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^^ meta.annotation.identifier.java +// ^^^^^^^^^ storage.type.class.java +// ^ keyword.operator.logical.java +// ^^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + } + + void genericTypeCastExpression() { + + (a < b) foo; +// ^^^^^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (a < b) ~ foo; +// ^^^^^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^ keyword.operator.bitwise.java +// ^^^ variable.other.java + + (List) foo; +// ^^^^^ meta.cast.java meta.group.java - meta.generic +// ^^^ meta.cast.java meta.group.java meta.generic.java +// ^ meta.cast.java meta.group.java - meta.generic +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (List[]) foo; +// ^^^^^ meta.cast.java meta.group.java - meta.generic +// ^^^ meta.cast.java meta.group.java meta.generic.java +// ^^^ meta.cast.java meta.group.java - meta.generic +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (list) foo; +// ^^^^^ meta.cast.java meta.group.java - meta.generic +// ^^^ meta.cast.java meta.group.java meta.generic.java +// ^ meta.cast.java meta.group.java - meta.generic +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (list[]) foo; +// ^^^^^ meta.cast.java meta.group.java - meta.generic +// ^^^ meta.cast.java meta.group.java meta.generic.java +// ^^^ meta.cast.java meta.group.java - meta.generic +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (list[] & OtherList & None) foo; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.cast.java meta.group.java +// ^ punctuation.section.group.begin.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^ storage.modifier.array.java +// ^ keyword.operator.logical.java +// ^^^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ keyword.operator.logical.java +// ^^^^ storage.type.class.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + () foo; +// ^ meta.cast.java meta.group.java - meta.generic +// ^^^ meta.cast.java meta.group.java meta.generic.java +// ^ meta.cast.java meta.group.java - meta.generic +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + ([]) foo; +// ^ meta.cast.java meta.group.java - meta.generic +// ^^^ meta.cast.java meta.group.java meta.generic.java +// ^^^ meta.cast.java meta.group.java - meta.generic +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + () foo; +// ^ meta.cast.java meta.group.java - meta.generic +// ^^^ meta.cast.java meta.group.java meta.generic.java +// ^ meta.cast.java meta.group.java - meta.generic +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + ([]) foo; +// ^ meta.cast.java meta.group.java - meta.generic +// ^^^ meta.cast.java meta.group.java meta.generic.java +// ^^^ meta.cast.java meta.group.java - meta.generic +// ^^^^ - meta.cast - meta.group +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.generic.begin.java +// ^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^^ storage.modifier.array.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + } + + void noCastExpressionsTests() { + + (a + b) foo; +// ^^^^^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + + (a < b) & foo; +// ^^^^^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ keyword.operator.bitwise.java +// ^^^ variable.other.java + + (0) foo; +// ^^^ meta.group.java +// ^ punctuation.section.group.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^^^ variable.other.java + } +} + + +/****************************************************************************** + * Instance Type Comparison Expressions Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.20.2 + *****************************************************************************/ + +class TypeComparisonExpressionsTests { + + void instanceofPrimitiveTests { + + instanceof +// ^^^^^^^^^^ keyword.other.storage.instanceof.java + + instanceof boolean +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^^^^^ storage.type.primitive.java + + instanceof boolean[] +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^^^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java + + instanceof boolean@anno[] +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^^^^^ storage.type.primitive.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^ storage.modifier.array.java + + instanceof char +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^^ storage.type.primitive.java + + instanceof char[] +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java + + instanceof char@anno[] +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^^ storage.type.primitive.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^ storage.modifier.array.java + + instanceof int +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^ storage.type.primitive.java + + instanceof int[] +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^ storage.type.primitive.java +// ^^ storage.modifier.array.java + + instanceof int@anno[] +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^ storage.type.primitive.java +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java +// ^^ storage.modifier.array.java + + instanceof +// ^^^^^^^^^^ keyword.other.storage.instanceof.java + int +// ^^^ storage.type.primitive.java + @anno +// ^ punctuation.definition.annotation.java +// ^^^^ variable.annotation.java + [] +// ^^ storage.modifier.array.java +} + + void instanceofClassTests { + + a instanceof b +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^ storage.type.class.java + + a instanceof b.c +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java + + a instanceof b.c.d +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ storage.type.class.java + + a instanceof Object +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^^^^ storage.type.class.java +} + + void instanceofGenericsTests { + + instanceof +// ^^^^^^^^^^ keyword.other.storage.instanceof.java + + instanceof X.Y +// ^^^^^^^^^^ keyword.other.storage.instanceof.java + } + + void instanceofAmbigultyTests { + + a = b instanceof c?1__1:0b11110101; +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ variable.other.java +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^ storage.type.class.java +// ^ keyword.operator.ternary.java +// ^^^^ constant.numeric.value.java +// ^ keyword.operator.ternary.java +// ^^ constant.numeric.base.java +// ^^^^^^^^ constant.numeric.value.java +// ^ punctuation.terminator.java + } + // <- meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java + + void instanceofPatternsTests () { + + obj instanceof String s && s.length() > 5 +// ^^^ variable.other.java +// ^^^^^^^^^^ keyword.other.storage.instanceof.java +// ^^^^^^ storage.type.class.java +// ^ variable.other.java +// ^^ keyword.operator.logical.java +// ^ variable.other.java +// ^ punctuation.accessor.dot.java +// ^^^^^^ variable.function.java +// ^^ meta.group.java +// ^ keyword.operator.comparison.java +// ^ constant.numeric.value.java + } +} +// <- meta.class.java meta.block.java punctuation.section.block.end.java + + +/****************************************************************************** + * Lambda Expressions Tests + * https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.27 + *****************************************************************************/ + +class LambdasExpressionsTests { + + void anonymousFunctions() { + + Function func = a -> 42; +// ^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java + foo(a -> 42); +// ^^^ meta.function-call.identifier.java +// ^^^^^^^^^ meta.function-call.arguments.java meta.group.java +// ^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + a -> { return 42; }; +// ^^^^^^^^^^^^^^ meta.function.anonymous.java + + (a, b) -> 42; +// ^ variable.parameter.java +// ^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java + + (int a, Foo[] b) -> 42; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.function.anonymous meta.function.anonymous +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java meta.group.java +// ^^^^^^ meta.function.anonymous.java - meta.group +// ^^^ storage.type.primitive +// ^ variable.parameter.java +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java + + ( +// ^^ meta.function.anonymous.parameters.java meta.group.java - meta.function.anonymous meta.function.anonymous +// ^ punctuation.section.group.begin.java + int a, +// ^^^^^^^^ meta.function.anonymous.parameters.java meta.group.java - meta.function.anonymous meta.function.anonymous +// ^^^ storage.type.primitive +// ^ variable.parameter.java +// ^ punctuation.separator.comma.java + Foo[] b +// ^^^^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java meta.group.java - meta.function.anonymous meta.function.anonymous +// ^^^ storage.type.class.java +// ^ punctuation.section.generic.begin.java +// ^^^^^^^ storage.type.class.java +// ^ punctuation.section.generic.end.java +// ^ variable.parameter.java + ) +// ^ meta.function.anonymous.parameters.java meta.group.java punctuation.section.group.end.java - meta.function.anonymous meta.function.anonymous +// ^ meta.function.anonymous.java - meta.function.anonymous meta.function.anonymous + -> +// ^^^ meta.function.anonymous.java - meta.function.anonymous meta.function.anonymous +// ^^ keyword.declaration.function.arrow.java + 42; +// ^^^ meta.function.anonymous.java - meta.function.anonymous meta.function.anonymous +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java + + foo.forEach((k, v) -> { +// ^^^^^^^^^^^^ meta.function-call.arguments.java +// ^^^^^^ meta.function.anonymous.parameters.java meta.group.java +// ^ punctuation.section.group.begin.java +// ^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^^^^^^ meta.function.anonymous.java +// ^^ keyword.declaration.function.arrow.java +// ^ punctuation.section.block.begin + return; +// ^^^^^^^^^ meta.function-call.arguments.java meta.group.java meta.function.anonymous.java meta.block.java +// ^^^^^^ meta.statement.flow.return.java keyword.control.flow.return.java +// ^ punctuation.terminator.java - meta.statement.flow.return + }); +// ^ punctuation.section.block.end.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + a = (int) a + (a, int b) -> { return c }; +// ^^^^^ meta.cast.java meta.group.java +// ^^^^^ - meta.group +// ^^^^^^^^^^ meta.function.anonymous.parameters.java meta.group.java +// ^^^^ meta.function.anonymous.java - meta.group - meta.function.anonymous meta.block +// ^^^^^^^^^^^^ meta.function.anonymous.java meta.block.java +// ^ - meta.function.anonymous +// ^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^ punctuation.section.group.begin.java +// ^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^^ keyword.declaration.function.arrow.java +// ^ punctuation.section.block.begin.java +// ^^^^^^ keyword.control.flow.return.java +// ^ variable.other.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + + a = ((int) a + (a, int b) -> { return c }); +// ^ meta.group.java - meta.group meta.group +// ^^^^^ meta.group.java meta.cast.java meta.group.java +// ^^^^^ meta.group.java - meta.group meta.group +// ^^^^^^^^^^ meta.group.java meta.function.anonymous.parameters.java meta.group.java +// ^^^^ meta.group.java meta.function.anonymous.java - meta.group meta.group - meta.function.anonymous meta.block +// ^^^^^^^^^^^^ meta.group.java meta.function.anonymous.java meta.block.java +// ^ - meta.function.anonymous - meta.group meta.group +// ^ - meta.group +// ^^ punctuation.section.group.begin.java +// ^^^ storage.type.primitive.java +// ^ punctuation.section.group.end.java +// ^ variable.other.java +// ^ keyword.operator.arithmetic.java +// ^ punctuation.section.group.begin.java +// ^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^^^ storage.type.primitive.java +// ^ variable.parameter.java +// ^ punctuation.section.group.end.java +// ^^ keyword.declaration.function.arrow.java +// ^ punctuation.section.block.begin.java +// ^^^^^^ keyword.control.flow.return.java +// ^ variable.other.java +// ^ punctuation.section.block.end.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + } +//^ meta.class.java meta.block.java meta.function.java meta.block.java punctuation.section.block.end.java + + // Lambda parameter tests + Function lambda1 = (final @MyAnnotation String foo) -> foo; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^^^ storage.modifier.java +// ^^^^^^^^^^^^^ meta.annotation +// ^ punctuation.definition.annotation +// ^^^^^^ storage.type.class.java - meta.annotation +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda2 = (@MyAnnotation String foo) -> foo; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^^^^^^^^^^^ meta.annotation +// ^ punctuation.definition.annotation +// ^^^^^^ storage.type.class.java - meta.annotation +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda3 = (@MyAnnotation(foo = Foo.BAR) String foo) -> foo; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation +// ^ punctuation.definition.annotation +// ^^^ variable.parameter.java +// ^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^ constant.other.java +// ^^^^^^ storage.type.class.java - meta.annotation +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda4 = (String foo) -> foo; +// ^^^^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^^^^ storage.type.class.java - meta.annotation +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda4 = (var foo) -> foo; +// ^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^ storage.type.variant.java +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda5 = (foo) -> foo; +// ^^^^^ meta.function.anonymous.parameters.java +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda5 = (foo = 0) -> foo; +// ^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^ variable.parameter.java +// ^ invalid.illegal.expect-terminator.java +// ^ invalid.illegal.expect-terminator.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda6 = (foo, foo) -> foo; +// ^^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda7 = (Foo, Foo) -> foo; +// ^^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda8 = foo -> foo; +// ^^^ meta.function.anonymous.parameters.java +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + Function lambda9 = (String... foo) -> foo[0]; +// ^^^^^^^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^^^^ storage.type.class.java - meta.annotation +// ^^^ keyword.operator.variadic.java +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + IntFunction intLambda1 = (int foo) -> String.valueOf(foo); +// ^^^^^^^^^ meta.function.anonymous.parameters.java +// ^^^ storage.type.primitive - meta.annotation +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java - meta.function.anonymous.parameters.java + + MyObject objLambda = arg -> new MyObject(arg); +// ^^^ meta.function.anonymous.parameters.java variable.parameter.java +// ^^^^^^^^^^^^^^^^^^^^^ meta.function.anonymous.java +// ^^ keyword.declaration.function.arrow.java +// ^^^ keyword.other.storage.new.java +// ^^^^^^^^ storage.type.class.java +// ^ punctuation.section.group.begin.java +// ^^^^^ meta.group.java +// ^^^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ punctuation.terminator.java + + Function BLOCK_LAMBDA = foo -> { return 1; }; +// ^^^^^^^^^^^^ entity.name.constant.java +// ^ keyword.operator.assignment.java +// ^^^ variable.parameter.java +// ^^ keyword.declaration.function.arrow.java +// ^ meta.block punctuation.section.block.begin +// ^^^^^^ keyword.control.flow.return.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java +// ^ punctuation.section.block.end.java +// ^ punctuation.terminator.java + + Supplier supplier = () -> true; +// ^ keyword.operator.assignment.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^^ keyword.declaration.function.arrow.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java +} + + +/****************************************************************************** + * Annotation Tests + *****************************************************************************/ + +@ClassName.FixMethodOrder( MethodSorters.NAME_ASCENDING ) +// <- meta.class.java meta.annotation.identifier.java punctuation.definition.annotation.java - meta.annotation meta.annotation +//^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.annotation.identifier.java - meta.annotation meta.annotation +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.annotation.parameters.java meta.group.java - meta.annotation meta.annotation +//^^^^^^^^ variable.annotation.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^^^^ variable.annotation.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^^^^ constant.other.java +public class GrafoTest { + @Override +// ^^^^^^^^^ meta.annotation..identifier.java +// ^ punctuation.definition.annotation.java +// ^^^^^^^^ variable.annotation.java + void test1() { +// ^ entity.name.function + } + + @Author(first = "Oompah", last +// ^ meta.annotation.identifier.java +// ^^^^^^ meta.annotation.identifier.java +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation.parameters.java +// ^ punctuation.definition.annotation +// ^^^^^^ variable.annotation.java +// ^ punctuation.section.group.begin +// ^^^^^ variable.parameter.java +// ^ keyword.operator +// ^^^^^^^^ string +// ^ punctuation.separator.comma.java +// ^^^^ variable.parameter.java + = "Loompah") +//^^^^^^^^^^^^^^^^^^ meta.annotation.parameters.java +// ^ keyword.operator.assignment.java +// ^^^^^^^^ string +// ^ punctuation.section.group.end + void test2() { +// ^ entity.name.function + + Grafo grafo = new Grafo( true ); + final Grafo temposMaisCedo = new Grafo( true ); +// ^ storage.modifier +// ^ storage.type.class + } + + + @Partial @Mock(type=Grafo.class) DataLoader inline; +// ^^^^^^^^ meta.annotation +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.annotation +// ^ storage.type.class + + @Override public int inline() { +// ^^^^^^^^^ meta.annotation +// ^ punctuation.definition.annotation +// ^^^^^^^^ variable.annotation + } + + void annotatedArgs(@NonNull final String p1, +// ^^^^^^^^ meta.annotation +// ^ storage.modifier - meta.annotation + @Named(value = "") List p2, @NonNull final String p3) {} +// ^^^^^^^^^^^^^^^^^^ meta.annotation +// ^ storage.type.class +// ^ meta.generic punctuation.section.generic.begin +// ^ variable.parameter +// ^ punctuation.separator +// ^^^^^^^^ meta.annotation +// ^ storage.modifier - meta.annotation +// ^ storage.type.class + +} + +@MultiLineAnnotation( +// <- meta.class.java meta.annotation.identifier.java punctuation.definition.annotation.java +//^^^^^^^^^^^^^^^^^^ meta.class.java meta.annotation.identifier.java variable.annotation.java +// ^ meta.class.java meta.annotation.parameters.java punctuation.section.group.begin.java + foo = BAR, +//^^^ variable.parameter.java +// ^ keyword.operator.assignment.java +// ^ constant.other.java +// ^ punctuation.separator.comma.java + other = "foo" +//^^^^^ variable.parameter.java +// ^ keyword.operator.assignment.java +// ^ string +) +// <- meta.class.java meta.annotation.parameters.java punctuation.section.group.end.java +@fully.qualified.Annotation +// <- meta.class.java meta.annotation.identifier.java punctuation.definition.annotation.java +//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.annotation.identifier.java meta.path.java +//^^^^ variable.annotation.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ variable.annotation.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ variable.annotation.java +@fully.qualified.ParentClass.InnerAnnotation +// <- meta.class.java meta.annotation.identifier.java punctuation.definition.annotation.java +//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.annotation.identifier.java meta.path.java +//^^^^ variable.annotation.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^ variable.annotation.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^ variable.annotation.namespace.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^^^^^^ variable.annotation.java +@fully.qualified +// <- meta.class.java meta.annotation.identifier.java punctuation.definition.annotation.java +//^^^^^^^^^^^^^^ meta.class.java meta.annotation.identifier.java meta.path.java + .multiline.Annotation +// ^^^^^^^^^^^^^^^^^^^^^ meta.class.java meta.annotation.identifier.java meta.path.java + (foo = "bar") +// ^^^^^^^^^^^^^ meta.class.java meta.annotation.parameters.java -meta.annotation.identifier.java +@FancyAnnotation ({ +//^^^^^^^^^^^^^^^^^^ - meta.annotation meta.annotation +// <- meta.class.java meta.annotation.identifier.java punctuation.definition.annotation.java +//^^^^^^^^^^^^^^^ meta.class.java meta.annotation.identifier.java +// ^^ meta.class.java meta.annotation.parameters.java + Foo.class, +//^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java - storage.type.java +// ^ punctuation.separator.comma.java + Bar.class +//^^^ storage.type.class.java +// ^ punctuation.accessor.dot.java +// ^^^^^ variable.language.class.java - storage.type.java +}) +// <- punctuation.section.braces.end.java + // <- meta.class.java meta.annotation.parameters.java punctuation.section.group.end.java +class Bàr { +// ^^^ entity.name.class.java + Bàr() {} +//^^^^^ meta.function +//^^^ entity.name.function.constructor.java +} + +@AnnotationAsParameterSingle( + @Parameter(name = "foo") +// ^ punctuation.definition.annotation.java +// ^^^^^^^^^ variable.annotation.java +// ^^^^ variable.parameter.java +) + +@AnnotationAsParameterSingleNamed( + value = @Parameter(name = "foo") +//^^^^^ variable.parameter.java +// ^ punctuation.definition.annotation.java +// ^^^^^^^^ variable.annotation.java +// ^^^^ variable.parameter.java +) + +@AnnotationAsParameterMultiple + ({ +// <- meta.annotation.identifier.java - meta.annotation meta.annotation +//^ meta.class.java meta.annotation.identifier.java - meta.annotation meta.annotation +// ^^^ meta.annotation.parameters.java meta.group.java +// ^ punctuation.section.braces.begin.java + @Parameter(name = "foo"), +// ^ punctuation.definition.annotation.java +// ^^^^^^^^^ variable.annotation.java +// ^^^^ variable.parameter.java + + @Parameter(name = "bar") +// ^ punctuation.definition.annotation.java +// ^^^^^^^^^ variable.annotation.java +// ^^^^ variable.parameter.java +}) +// <- punctuation.section.braces.end.java + +@AnnotationAsParameterMultipleNamed( + first = {@Parameter(name = "foo"), @Parameter(name = "bar")}, +//^^^^^ variable.parameter.java +// ^ punctuation.definition.annotation.java +// ^^^^^^^^^ variable.annotation.java +// ^^^^ variable.parameter.java +// ^ punctuation.definition.annotation.java +// ^^^^^^^^^ variable.annotation.java +// ^^^^ variable.parameter.java + second = {@Parameter(name = "foo"), @Parameter(name = "bar")}, +//^^^^^^ variable.parameter.java + third = @Parameter(name = "foo") +//^^^^^ variable.parameter.java +// ^^^^^^^^^ variable.annotation.java +) + +@SomeInterface +// <- meta.class.java meta.annotation.identifier.java punctuation.definition.annotation.java +//^^^^^^^^^^^^ meta.class.java meta.annotation.identifier.java variable.annotation.java +public class Foo { +// <- meta.class.java storage.modifier.java +//^^^^ meta.class.java storage.modifier.java +// ^^^^^ meta.class.java +// ^^^ meta.class.identifier.java entity.name.class.java +// ^ meta.class.java meta.block.java punctuation.section.block.begin.java + + FooBar MY_CONST = new FooBar(); +// ^^^^^^^^ entity.name.constant.java + + @Inject +//^ meta.annotation.identifier.java punctuation.definition.annotation.java +// ^^^^^^ meta.annotation.identifier.java variable.annotation.java + public Foo( +//^ - meta.annotation +// ^ meta.function +// ^ entity.name.function.constructor + // Comment for annotation + @MyAnnotation FooType annotatedParam, +// ^ meta.annotation.identifier.java punctuation.definition.annotation.java +// ^^^^^^^^^^^^ meta.annotation.identifier.java variable.annotation.java +// ^ - meta.annotation.identifier.java - variable +// ^ - meta.annotation.identifier.java +// ^^^^^^^ storage.type.class.java +// ^^^^^^^^^^^^^^ variable.parameter.java + String unannotatedParam) { +// ^ storage.type.class.java +// ^ variable.parameter.java + return; +// ^^^^^^ keyword.control.flow.return.java + } + + public static void main(String[] args, String moreArgs, a.b.c.Foo bar) {} +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters.java +// ^^^^^^ storage.type.class.java +// ^^ storage.modifier.array.java +// ^^^^ variable.parameter.java +// ^ punctuation.separator.comma.java +// ^^^^^^ meta.generic.java +// ^^^^^^ storage.type.class.java +// ^^^^ storage.type.class.java +// ^^^^^^^^ variable.parameter.java +// ^ variable.namespace.java +// ^ punctuation.accessor.dot.java +// ^ punctuation.accessor.dot.java +// ^^^ storage.type.class.java +// ^^^ variable.parameter.java + + MyClass myClass = new MyClass( + SomeEnum.ENUM_VALUE, + new OtherNewClass(), + new OtherNestedClass( + SomeEnum.ENUM_VALUE, + new SuperNestedClass(param, 2)), + anotherParam); + + Object foo = new TypeLiteral< + StandardReferenceNumberProcessor< + SimpleGenerateReferenceNumberOperation, + SimpleSyncReferenceNumberOperation>>() {}; + + Object bar = SomeStaticClass.newBuilder().doThings(1) +// ^^^^^^^^^^ meta.function-call.identifier.java +// ^^ meta.function-call.arguments.java meta.group.java +// ^^^^^^^^ meta.function-call.identifier.java +// ^^^ meta.function-call.arguments.java meta.group.java +// ^^^^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ punctuation.section.group.end.java +// ^ punctuation.accessor.dot.java +// ^^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java + .withString("I am a string"); +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^ meta.function-call.identifier.java +// ^^^^^^^^^^^^^^^^^ meta.function-call.arguments.java meta.group.java +// ^^^^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^ string.quoted.double.java +// ^ punctuation.section.group.end.java + + Object bah = someStaticMethodCall(4) +// ^^^^^^^^^^^^^^^^^^^^ meta.function-call.identifier.java +// ^^^ meta.function-call.arguments.java meta.group.java +// ^^^^^^^^^^^^^^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.section.group.end.java + .withString("I am a string"); +// ^ punctuation.accessor.dot.java +// ^^^^^^^^^^ meta.function-call.identifier.java +// ^^^^^^^^^^^^^^^^^ meta.function-call.arguments.java meta.group.java +// ^^^^^^^^^^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^^^^^^^^^^^^^^^ string.quoted.double.java +// ^ punctuation.section.group.end.java + + +/****************************************************************************** + * Operators Tests + *****************************************************************************/ + + int operatorsTests() { + + == != <= >= <> < > +// ^^ keyword.operator.comparison.java +// ^^ keyword.operator.comparison.java +// ^^ keyword.operator.comparison.java +// ^^ keyword.operator.comparison.java +// ^^ keyword.operator.comparison.java +// ^ keyword.operator.comparison.java +// ^ keyword.operator.comparison.java + + ! && || +// ^ keyword.operator.logical.java +// ^^ keyword.operator.logical.java +// ^^ keyword.operator.logical.java + + << >> >>> ~ & | ^ +// ^^ keyword.operator.bitwise.java +// ^^ keyword.operator.bitwise.java +// ^^^ keyword.operator.bitwise.java +// ^ keyword.operator.bitwise.java +// ^ keyword.operator.bitwise.java +// ^ keyword.operator.bitwise.java +// ^ keyword.operator.bitwise.java + + ++ -- + - * / % +// ^^ keyword.operator.arithmetic.java +// ^^ keyword.operator.arithmetic.java +// ^ keyword.operator.arithmetic.java +// ^ keyword.operator.arithmetic.java +// ^ keyword.operator.arithmetic.java +// ^ keyword.operator.arithmetic.java +// ^ keyword.operator.arithmetic.java + + x = (e & 1) << c^2 >> 10; +// ^ keyword.operator.assignment.java +// ^ keyword.operator.bitwise.java +// ^^ keyword.operator.bitwise.java +// ^ keyword.operator.bitwise.java +// ^^ keyword.operator.bitwise.java + + y = ~e >>> (c | 2); +// ^ keyword.operator.assignment.java +// ^ keyword.operator.bitwise.java +// ^^^ keyword.operator.bitwise.java +// ^ keyword.operator.bitwise.java + + z += x; z -= x; z *= x; z /= x; z %= x; +// ^^ keyword.operator.assignment.augmented.java +// ^^ keyword.operator.assignment.augmented.java +// ^^ keyword.operator.assignment.augmented.java +// ^^ keyword.operator.assignment.augmented.java +// ^^ keyword.operator.assignment.augmented.java + + z &= x; z ^= x; z |= x; z <<= x; z >>= x; z >>>= x; +// ^^ keyword.operator.assignment.augmented.java +// ^^ keyword.operator.assignment.augmented.java +// ^^ keyword.operator.assignment.augmented.java +// ^^^ keyword.operator.assignment.augmented.java +// ^^^ keyword.operator.assignment.augmented.java +// ^^^^ keyword.operator.assignment.augmented.java + + b=e.a(b b?b:b; +// ^ meta.function-call.identifier.java +// ^^^^^ meta.function-call.arguments.java meta.group.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ variable.other.java +// ^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ keyword.operator.comparison.java +// ^ variable.other.java +// ^ keyword.operator.ternary.java +// ^ variable.other.java +// ^ keyword.operator.ternary.java +// ^ variable.other.java + + b=e.a(bb?b:b; +// ^ meta.function-call.identifier.java +// ^^^^^ meta.function-call.arguments.java meta.group.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^ variable.other.java +// ^ variable.function.java +// ^ punctuation.section.group.begin.java +// ^ variable.other.java +// ^ keyword.operator.comparison.java +// ^ variable.other.java +// ^ punctuation.section.group.end.java +// ^ keyword.operator.comparison.java +// ^ variable.other.java +// ^ keyword.operator.ternary.java +// ^ variable.other.java +// ^ keyword.operator.ternary.java +// ^ variable.other.java + + a[0] = true; +// ^^^^ - meta.variable meta.variable +// ^ meta.variable.identifier.java +// ^^^ meta.variable.item-access.java meta.brackets.java +// ^ variable.other.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ keyword.operator.assignment.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + a[0][0] = true; +// ^^^^^^^ - meta.variable meta.variable +// ^ meta.variable.identifier.java +// ^^^^^^ meta.variable.item-access.java meta.brackets.java +// ^ variable.other.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ keyword.operator.assignment.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + a [ 0 ] [ 0 ] = true; +// ^^^^^^^^^^^^^ - meta.variable meta.variable +// ^^ meta.variable.identifier.java +// ^^^^^ meta.variable.item-access.java meta.brackets.java +// ^ meta.variable.item-access.java - meta.brackets +// ^^^^^ meta.variable.item-access.java meta.brackets.java +// ^^^^^^^^^ - meta.variable +// ^ variable.other.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ keyword.operator.assignment.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + a /**/ [ /**/ 0 /**/ ] /**/ [ /**/ 0 /**/ ] /**/ = /**/ true; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.variable meta.variable +// ^^^^^^^ meta.variable.identifier.java +// ^^^^^^^^^^^^^^^ meta.variable.item-access.java meta.brackets.java +// ^^^^^^ meta.variable.item-access.java - meta.brackets +// ^^^^^^^^^^^^^^^ meta.variable.item-access.java meta.brackets.java +// ^^^^^ meta.variable.item-access.java - meta.brackets +// ^^^^^^^^^^^^^ - meta.variable +// ^ variable.other.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ keyword.operator.assignment.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + a +// ^^ meta.variable.identifier.java +// ^ variable.other.java + [ +//^^ meta.variable.identifier.java +// ^^ meta.variable.item-access.java meta.brackets.java +// ^ punctuation.section.brackets.begin.java + 0 +// ^^^ meta.variable.item-access.java meta.brackets.java +// ^ constant.numeric.value.java + ] +// ^^ meta.variable.item-access.java meta.brackets.java +// ^ punctuation.section.brackets.end.java + = +// ^ keyword.operator.assignment.java + true; +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + a.c = true; +// ^ - meta.variable +// ^ meta.variable.identifier.java +// ^ - meta.variable +// ^ meta.variable.identifier.java +// ^ - meta.variable +// ^ variable.other.java +// ^ punctuation.accessor.dot.java +// ^ variable.other.java +// ^ keyword.operator.assignment.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + a[0].c[1] = true; +// ^ - meta.variable +// ^ meta.variable.identifier.java +// ^^^ meta.variable.item-access.java meta.brackets.java +// ^ - meta.variable +// ^ meta.variable.identifier.java +// ^^^ meta.variable.item-access.java meta.brackets.java +// ^ - meta.variable +// ^ variable.other.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ punctuation.accessor.dot.java +// ^ variable.other.java +// ^ punctuation.section.brackets.begin.java +// ^ constant.numeric.value.java +// ^ punctuation.section.brackets.end.java +// ^ keyword.operator.assignment.java +// ^^^^ constant.language.boolean.java +// ^ punctuation.terminator.java + + int foo = true ? 1 : 2; +// ^^^^ constant.language.boolean.java +// ^ keyword.operator.ternary.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ keyword.operator.ternary.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java + + if (a == false) {} +// ^^ keyword.operator.comparison.java + + if (this.scale<0) { +// ^^ keyword.control.conditional.if.java +// ^^^^^^^^^^^^^^ meta.group.java +// ^ punctuation.section.group.begin +// ^ punctuation.accessor.dot.java +// ^ keyword.operator.comparison.java +// ^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ - meta.group.java + return foo<<32; +// ^^^^^^ keyword.control.flow.return.java +// ^^ keyword.operator.bitwise.java +// ^^ meta.number.integer.decimal.java constant.numeric.value.java +// ^ punctuation.terminator.java + } +// ^ meta.block.java punctuation.section.block.end.java + + return foo + + + +// ^^^^^^^^^^^^^^^ meta.tag + + +// ^^^^^^^^ meta.tag.style.end.html + + +// ^^^^^^^^^ meta.tag.script.end.html + + + + <%-- This is a comment --%> +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.block.jsp + + + + + <%@ include file="foo.bar" %> +// ^ - meta +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.embedded.directive.jsp +// ^ - meta +// ^^^ punctuation.section.embedded.begin.jsp +// ^^^^^^^ keyword.control.directive.jsp +// ^^^^ entity.other.attribute-name.jsp +// ^ punctuation.separator.key-value.jsp +// ^^^^^^^^^ string.quoted.double.jsp +// ^^ punctuation.section.embedded.end.jsp + + + + + <%! int i = 0; %> +// ^ - meta +// ^^^ meta.embedded.declaration.jsp - source.java.embedded.jsp +// ^^^^^^^^^^^^ meta.embedded.declaration.jsp source.java.embedded.jsp - source.java source.java +// ^^ meta.embedded.declaration.jsp - source.java.embedded.jsp +// ^ - meta +// ^^^ punctuation.section.embedded.begin.jsp +// ^^^ storage.type.primitive.java +// ^^ punctuation.section.embedded.end.jsp + + + + + The map file has <%= map.size() %> entries. +// ^^^^^^^^^^^^^^^^^ - meta +// ^^^^^^ meta.tag.inline.any.html - meta.attribute-with-value.html +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.inline.any.html meta.attribute-with-value.html +// ^ meta.string.html - meta.interpolation +// ^^^^^^^^^^^^^^^^^ meta.string.html meta.interpolation.jsp +// ^ meta.string.html - meta.interpolation +// ^^^ meta.embedded.expression.jsp punctuation.section.embedded.begin.jsp - source.java +// ^^^^^^^^^^^^ meta.embedded.expression.jsp source.java.embedded.jsp - source.java source.java +// ^^ meta.embedded.expression.jsp punctuation.section.embedded.end.jsp - source.java +// ^ meta.tag.inline.any.html - meta.attribute-with-value.html +// ^^^ meta.embedded.expression.jsp punctuation.section.embedded.begin.jsp - source.java +// ^^^^^^^^^^^^ meta.embedded.expression.jsp source.java.embedded.jsp +// ^^ meta.embedded.expression.jsp punctuation.section.embedded.end.jsp - source.java +// ^^^^^^^ meta.tag.inline.any.html +// ^^^^^^^^^ - meta + + + + + <% +// ^^ punctuation.section.embedded.begin.jsp - source.java.embedded.jsp +// ^ source.java.embedded.jsp - source.java source.java + if (!foo && !bar) { +// ^^ keyword.control.conditional.if.java +// ^ keyword.operator.logical.java +// ^^ keyword.operator.logical.java + %>
    <% +// ^^ punctuation.section.embedded.end.jsp - source.java.embedded.jsp +// ^^^^^ meta.tag.block.any.html - meta.attribute-with-value +// ^^^^^^^ meta.tag.block.any.html meta.attribute-with-value.style.html - source.css +// ^^^^^^^ meta.tag.block.any.html meta.attribute-with-value.style.html source.css - meta.expression +// ^^^^^^^^^ meta.tag.block.any.html meta.attribute-with-value.style.html source.css meta.embedded.expression.jsp +// ^ meta.tag.block.any.html meta.attribute-with-value.style.html - source.css +// ^^^^^^^ meta.tag.block.any.html - meta.attribute-with-value.style.html - source.css +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.block.any.html +// ^^^^^ entity.other.attribute-name.style.html +// ^ punctuation.separator.key-value.html +// ^ string.quoted.double punctuation.definition.string.begin.html +// ^^^^^ meta.property-name.css support.type.property-name.css +// ^ punctuation.separator.key-value.css +// ^^^ punctuation.section.embedded.begin.jsp - source.java.embedded +// ^^^^ source.java.embedded.jsp +// ^^ punctuation.section.embedded.end.jsp - source.java.embedded +// ^ string.quoted.double punctuation.definition.string.end.html +// ^ punctuation.definition.tag.end.html +// ^^ punctuation.section.embedded.begin.jsp - source.java.embedded.jsp + if (foot.shouldBe()) { +// ^^ keyword.control.conditional.if.java + boolean test = false; +// ^^^^^^^ storage.type +// ^^^^^ constant + %> +// ^^ punctuation.section.embedded.end.jsp - source.java.embedded.jsp +// ^ text.html.jsp - source.java.embedded.jsp + + <%-- This is a comment --%> +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.block.jsp + <% int aNumber = 0; // this scriptlet should close %> +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.line.double-slash.java +// ^^ punctuation.section.embedded.end.jsp + +
    +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag + <% +// ^^ punctuation.section.embedded.begin.jsp - source.java.embedded.jsp + } +// ^ - invalid.illegal.stray-brace-end + } +// ^ - invalid.illegal.stray-brace-end + %> +// ^^ punctuation.section.embedded.end.jsp - source.java.embedded.jsp +// ^ text.html.jsp - source.java.embedded.jsp + + + + + + +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.directive.end.html - meta.tag.jsp meta.tag.jsp +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.jsp.directive.begin.html - meta.tag.jsp meta.tag.jsp +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.accessor.dot.jsp +// ^^^^^^^ keyword.control.directive.jsp +// ^^^^ meta.attribute-with-value.href.html entity.other.attribute-name.href.html +// ^ meta.attribute-with-value.href.html punctuation.separator.key-value.html +// ^^^^^^^^^ meta.attribute-with-value.href.html string.quoted.double.html +// ^^ punctuation.definition.tag.end.html + + +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.jsp.directive.begin.html +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.directive.end.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.accessor.dot.jsp +// ^^^^^^^ keyword.control.directive.jsp +// ^^^^ meta.attribute-with-value.href.html entity.other.attribute-name.href.html +// ^ meta.attribute-with-value.href.html punctuation.separator.key-value.html +// ^^^^^^^^^ meta.attribute-with-value.href.html string.quoted.double.html +// ^ punctuation.definition.tag.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + + + + +// ^^^^^^^^^^^^^^^^^^ meta.tag.jsp.declaration.end.html - meta.tag.jsp meta.tag.jsp +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + int i = 0; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^^^^^^^^^ meta.tag.jsp.declaration.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^^ entity.name.tag.localname.html +// ^^ punctuation.definition.tag.end.html +// ^^^^^^^^^^ - source.java.embedded +// ^^^^^^^^^^^^^^^^^^ meta.tag.jsp.declaration.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + int i = 0; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^^^^^^^^ meta.tag.jsp.declaration.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^^^^^^^^ source.java.embedded.jsp - source.java source.java +// ^^^ storage.type.primitive.java +// ^^^^^^^^^^^^^^^^^^ meta.tag.jsp.declaration.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + + + variable +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.expression.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^^^^^^ source.java.embedded.jsp variable.other.java - source.java source.java +// ^^^^^^^^^^^^^^^^^ meta.tag.jsp.expression.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + Good guess, but nope. Trynumguess.getHint(). +// ^^^^^^^^^^^^^^^^^^^^^^^^^ - meta +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^ meta.tag.inline.any.html +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.expression.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^^^^^^^^^^^^^^^^ source.java.embedded.jsp - source.java source.java +// ^^^^^^^^^^^^^^^^^ meta.tag.jsp.expression.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^^ meta.tag.inline.any.html + + Good guess, but nope. Trynumguess.getHint(). +// ^^^^^^^^^^^^^^^^^^^^^^^^^ - meta +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^ meta.tag.inline.any.html +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.expression.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^ entity.name.tag.localname.html +// ^^ punctuation.definition.tag.end.html +// ^^^^^^^^^^^^^^^^^^ - source.java.embedded +// ^^^^^^^^^^^^^^^^^ meta.tag.jsp.expression.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^^ meta.tag.inline.any.html + + + + + + +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.scriptlet.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + int i; +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.scriptlet.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^^ punctuation.definition.tag.end.html +// ^^^^^^ - source +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.scriptlet.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + int i = (1 >< 5); +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^^^^^^ meta.tag.jsp.scriptlet.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^^^^^^^^^^^^^^^^^^ source.java.embedded.jsp +// ^^^^ constant.character.entity.named.html +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.scriptlet.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^^^^^^ meta.tag.jsp.scriptlet.begin.html +// ^^^^^^^^^ meta.tag.sgml.cdata.html +// ^^^ meta.tag.sgml.cdata.html +// ^^^^^^^^^^^^^^^^ meta.tag.jsp.scriptlet.end.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^ punctuation.definition.tag.begin.html +// ^^^^^ keyword.declaration.cdata.html +// ^ punctuation.definition.tag.begin.html +// ^^^^^^^^^^^^^^^^^^^^ source.java.embedded.jsp +// ^^^^ constant.character.entity.named.html +// ^^^ punctuation.definition.tag.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + +//^^^ meta.tag.jsp.scriptlet.begin.html +// ^ punctuation.definition.tag.end.html +// ^ source.java.embedded.jsp - meta.tag + out.println("Starting"); +// ^^^^^^^^^^^^^^^^^^^^^^^^ source.java.embedded.jsp + // Note we need to declare CDATA because we don't escape the less than symbol + +// ^^^ source.java.embedded.jsp meta.tag.sgml.cdata.html punctuation.definition.tag.end.html + out.println("Done!"); +// ^^^^^^^^^^^^^^^^^^^^^ source.java.embedded.jsp + +//^^^ meta.tag.jsp.scriptlet.end.html +// ^ - meta.tag +// ^ punctuation.definition.tag.end.html + + + + + +// ^ meta.tag.jsp.other.begin.html punctuation.definition.tag.end.html + + +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.jsp.other.begin.html - meta.tag.jsp meta.tag.jsp +// ^ meta.attribute-with-value.href.html meta.string.html - meta.path +// ^^^^^^^^^^^^^^ meta.attribute-with-value.href.html meta.path.url.html meta.string.html +// ^ meta.attribute-with-value.href.html meta.string.html - meta.path +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^ entity.name.tag.localname.html +// ^^^^ meta.attribute-with-value.href.html entity.other.attribute-name.href.html +// ^ meta.attribute-with-value.href.html punctuation.separator.key-value.html +// ^^^^^^^^^^^^^^^^ string.quoted.double.html +// ^ punctuation.definition.string.begin.html +// ^ punctuation.separator.path.html +// ^ punctuation.separator.path.html +// ^ punctuation.definition.string.end.html +// ^^ punctuation.definition.tag.end.html + + +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.jsp.other.begin.html - meta.tag.jsp meta.tag.jsp +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.tag.jsp.other.begin.html - meta.tag.jsp meta.tag.jsp +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^ entity.name.tag.localname.html +// ^^ punctuation.definition.tag.end.html + + +// ^^^^^^^^^^^^^^ meta.tag.jsp.other.end.html - meta.tag.jsp meta.tag.jsp +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + +// ^^^^^^^^^^^ meta.tag.jsp.other.end.html - meta.tag.jsp meta.tag.jsp +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + + Plain text +// ^^^^^^^^^^ text.html.jsp - meta + + Plaintext +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^^ meta.tag.jsp.other.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^ entity.name.tag.localname.html +// ^^ punctuation.definition.tag.end.html +// ^^^ meta.tag.inline.any.html +// ^^^^ meta.tag.inline.any.html +// ^^^^^^^^^^^ meta.tag.jsp.other.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + Plaintext +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^ meta.tag.jsp.other.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^ meta.tag.inline.any.html +// ^^^^ meta.tag.inline.any.html +// ^^^^^^^^^^^ meta.tag.jsp.other.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + Plain<b>text     +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - meta.tag.jsp meta.tag.jsp +// ^^^^^^^^^^ meta.tag.jsp.other.begin.html +// ^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^^ constant.character.entity.named.html +// ^^^^ constant.character.entity.named.html +// ^^^^ meta.tag.inline.any.html +// ^^^^^^^^^^^^ meta.tag.jsp.other.end.html +// ^^ punctuation.definition.tag.begin.html +// ^^^ entity.name.tag.namespace.html +// ^ punctuation.separator.namespace.html +// ^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html +// ^^^ meta.tag.inline.any.html + + +// ^ meta.tag.other.begin.html meta.attribute-with-value.html meta.string.html - meta.interpolation +// ^^^^^^^^^^^^ meta.tag.other.begin.html meta.attribute-with-value.html meta.string.html meta.interpolation.jsp +// ^ meta.tag.other.begin.html meta.attribute-with-value.html meta.string.html - meta.interpolation +// ^ meta.tag.other.begin.html - meta.string - meta.interpolation +// ^ string.quoted.double.html punctuation.definition.string.begin.html +// ^^ punctuation.section.interpolation.begin.jsp +// ^^^^^^^^^ source.java.embedded.jsp meta.variable.identifier.java variable.other.java +// ^ punctuation.section.interpolation.end.jsp +// ^ string.quoted.double.html punctuation.definition.string.end.html + + +// ^^^^^^^^^^^^ meta.tag.other.end.html +// ^^ punctuation.definition.tag.begin.html +// ^ entity.name.tag.namespace.html +// ^ entity.name.tag.html punctuation.separator.namespace.html +// ^^^^^^^ entity.name.tag.localname.html +// ^ punctuation.definition.tag.end.html + + + diff --git a/LaTeX/syntax_test_latex.tex b/LaTeX/syntax_test_latex.tex index 3870a3f1dc..77910bc6c7 100644 --- a/LaTeX/syntax_test_latex.tex +++ b/LaTeX/syntax_test_latex.tex @@ -415,7 +415,7 @@ \subsubsection{name} % <- meta.environment.verbatim.lstlisting.latex % <- meta.environment.embedded.java.latex % <- source.java.embedded -% ^ storage.type.java +% ^ keyword.declaration.class.java } \end{lstlisting}

    • Description that starts with tag -// ^^^ text.html.javadoc meta.tag - */ - - /** One-liner with tags */ -// ^^^ text.html.javadoc meta.tag -// ^^^ text.html.javadoc meta.tag - - /** @param onFirstLine @param -// ^^^^^^ keyword.other.documentation.param.javadoc -// ^^^^^^ -keyword.other.documentation.param.javadoc - * @param normal @param -// ^^^^^^ -keyword.other.documentation.param.javadoc -// ^^^^^^ keyword.other.documentation.param.javadoc - * - @param withoutAsterisk @param -// ^^^^^^ -keyword.other.documentation.param.javadoc -// ^^^^^^ keyword.other.documentation.param.javadoc - */ - - /** - * Parameters - * - * @param paramName Some description -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.block-tag.javadoc -// ^^^^^^^^^ variable.parameter.javadoc - * that spans several lines. -// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.block-tag.javadoc -// ^^^ meta.tag -// ^^^^ meta.tag -// ^ punctuation.definition.comment.javadoc - * - * @param - * paramName1 -// ^^^^^^^^^^ variable.parameter.javadoc - * Parameter description -// ^^^^^^^^^^^^^^^^^^^^^ meta.block-tag.javadoc - * - * @param - * paramName2 -// ^^^^^^^^^^ variable.parameter.javadoc - * - * @param - * @param - * paramName3 -// ^^^^^^^^^^ variable.parameter.javadoc - */ -// ^^ punctuation.definition.comment.end.javadoc - - /** Not a @param tag */ -// ^^^^^^^^^^^^^^^^^^^^^^ comment.block.documentation.javadoc -// ^^^^^^ -keyword.other.documentation.param.javadoc - - /** - * Code blocks - * - * {@code} {@literal} -// ^^^^^ keyword.other.documentation.code-or-literal.javadoc -// ^ punctuation.definition.keyword.javadoc -// ^^^^^^^^ keyword.other.documentation.code-or-literal.javadoc -// ^ punctuation.definition.keyword.javadoc - - * {@code List lst = new ArrayList<>()} -// ^ punctuation.section.inline-tag.begin.javadoc -// ^^^^^ keyword.other.documentation.code-or-literal.javadoc -// ^ -markup.raw.javadoc -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.raw.javadoc -meta.tag -// ^ punctuation.section.inline-tag.end.javadoc - - * Multiline, line break in content: {@code x + y -// ^^^^^ markup.raw.javadoc -// ^ -markup.raw.javadoc - * = z} -//^^^ -markup.raw.javadoc -// ^^^ markup.raw.javadoc - - * Multiline, line break before content: {@literal -// ^ -markup.raw.javadoc - * x + y = z} -//^^^ -markup.raw.javadoc -// ^^^^^^^^^ markup.raw.javadoc - - * Bracket balancing: {@code int[][] a = {{1, 2, 3}, {4, 5}}} -// ^ punctuation.section.inline-tag.begin.javadoc -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.raw.javadoc -// ^ punctuation.section.inline-tag.end.javadoc - - * Bracket balancing with line break: {@code int[][] a = { -// ^ punctuation.section.inline-tag.begin.javadoc -// ^^^^^^^^^^^^^ markup.raw.javadoc -// ^ -markup.raw.javadoc - * {1, 2, 3}, {4, 5}}} -//^^^ -markup.raw.javadoc -// ^^^^^^^^^^^^^^^^^^ markup.raw.javadoc -// ^ punctuation.section.inline-tag.end.javadoc - */ - - /** - * Inline tags with references - - * {@link} {@linkplain} -// ^^^^^ keyword.other.documentation.link.javadoc -// ^^^^^^^^^^ keyword.other.documentation.link.javadoc - - * {@link Class} {@linkplain org.package.Class} {@link org.package.Class.NestedClass} -// ^^^^^ keyword.other.documentation.link.javadoc -// ^^^^^ markup.underline.link.javadoc -// ^^^^^^^^^ keyword.other.documentation.link.javadoc -// ^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc - - * Method separator: - * {@link package.Class#method} {@linkplain #method} -// ^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc -// ^^^^^^^ markup.underline.link.javadoc - - * Brackets: - * {@link Class#method(Type, Type)} {@link #method(Type, Type) label} -// ^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc -// ^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc -// ^^^^^ meta.label.javadoc -markup.underline.link.javadoc - - * Line breaks: - * {@link Class#method(Type, - * Type, Type) label} -// ^^^^^^^^^^^ markup.underline.link.javadoc -// ^^^^^ meta.label.javadoc -//^^^ -markup.underline.link.javadoc - * {@link - * Class#method(Type, Type, Type) label} -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc -// ^^^^^ meta.label.javadoc - * {@link Class#method(Type, Type, Type) - * label} -// ^^^^^ meta.label.javadoc - * - * Tags in label: - * {@link Class#method(Type, Type, Type) label} -// ^^^^^^^^^^^^ meta.label.javadoc -// ^^^ meta.tag -// ^^^^ meta.tag - * - * {@value} {@value #SOME_CONSTANT} {@value package.Class#SOME_CONSTANT} -// ^^^^^^ keyword.other.documentation.value.javadoc -// ^^^^^^^^^^^ markup.underline.link.javadoc -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc - */ - - /** - * Block tags with reference - * - * @see Class#method(Type, Type) -// ^^^^ keyword.other.documentation.see.javadoc -// ^^^^^^^^^^^^^^^^^^^^^^^^ markup.underline.link.javadoc - * - * @see java.util.stream -// ^^^^ keyword.other.documentation.see.javadoc -// ^^^^^^^^^^^^^^^^^^^^^^^ -markup.underline.link.javadoc -// ^^^ meta.tag -// ^^^ meta.tag - * - * @see 'java.util.stream' -// ^^^^ keyword.other.documentation.see.javadoc -// ^^^^^^^^^^^^^^^^^^ -markup.underline.link.javadoc - * - * @throws IOException -// ^^^^^^^ keyword.other.documentation.throws.javadoc -// ^^^^^^^^^^^ markup.underline.link.javadoc - - * @throws IOException because IOException -// ^^^^^^^ keyword.other.documentation.throws.javadoc -// ^^^^^^^^^^^ markup.underline.link.javadoc -// ^^^^^^^^^^^^^^^^^^^ - markup.underline.link.javadoc - */ - - /** - * Leading asterisk with space -// ^ punctuation.definition.comment.javadoc - *Without space -// ^ punctuation.definition.comment.javadoc - *