github-linguist-grammars 4.6.0

data/grammars/source.xq.json

@@ -0,0 +1,241 @@
+{
+  "scopeName": "source.xq",
+  "fileTypes": [
+    "xq",
+    "xql",
+    "xqm",
+    "xqy",
+    "xquery"
+  ],
+  "firstLineMatch": "^\\bxquery\\s+version\\b.*",
+  "foldingStartMarker": "^\\s*(<[^!?%/](?!.+?(/>|</.+?>))|<[!%]--(?!.+?--%?>)|<%[!]?(?!.+?%>))|(declare|.*\\{\\s*(//.*)?$)",
+  "foldingStopMarker": "^\\s*(</[^>]+>|[/%]>|-->)\\s*$|(.*\\}\\s*;?\\s*|.*;)",
+  "name": "XQuery",
+  "patterns": [
+    {
+      "begin": "^(?=jsoniq\\s+version\\s+)",
+      "end": "\\z",
+      "patterns": [
+        {
+          "include": "source.jq"
+        }
+      ]
+    },
+    {
+      "begin": "\\(#",
+      "end": "#\\)",
+      "name": "constant.xquery"
+    },
+    {
+      "begin": "\\(:~",
+      "end": ":\\)",
+      "name": "comment.doc.xquery",
+      "patterns": [
+        {
+          "name": "constant.language.xquery",
+          "match": "@[a-zA-Z0-9_\\.\\-]+"
+        }
+      ]
+    },
+    {
+      "include": "#XMLComment"
+    },
+    {
+      "include": "#CDATA"
+    },
+    {
+      "include": "#PredefinedEntityRef"
+    },
+    {
+      "include": "#CharRef"
+    },
+    {
+      "begin": "<\\?",
+      "end": "\\?>",
+      "name": "comment.xquery"
+    },
+    {
+      "begin": "\\(:",
+      "end": ":\\)",
+      "name": "comment.xquery"
+    },
+    {
+      "begin": "\"",
+      "end": "\"(?!\")",
+      "name": "string.xquery",
+      "patterns": [
+        {
+          "match": "\"\"",
+          "name": "constant.xquery"
+        },
+        {
+          "include": "#PredefinedEntityRef"
+        },
+        {
+          "include": "#CharRef"
+        }
+      ]
+    },
+    {
+      "begin": "'",
+      "end": "'(?!')",
+      "name": "string.xquery",
+      "patterns": [
+        {
+          "match": "''",
+          "name": "constant.xquery"
+        },
+        {
+          "include": "#PredefinedEntityRef"
+        },
+        {
+          "include": "#CharRef"
+        }
+      ]
+    },
+    {
+      "match": "%([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*:)?([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*)",
+      "name": "meta.declaration.annotation.xquery"
+    },
+    {
+      "match": "@(\\* | ([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*:)?([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*))",
+      "name": "support.type.xquery"
+    },
+    {
+      "match": "\\$([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*:)?([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*)",
+      "name": "meta.definition.variable.name.xquery"
+    },
+    {
+      "match": "\\b(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)[Ee][+#x002D]?[0-9]+\\b",
+      "name": "constant.numeric.jsoniq"
+    },
+    {
+      "match": "\\b(\\.[0-9]+|[0-9]+\\.[0-9]*)\\b",
+      "name": "constant.numeric.jsoniq"
+    },
+    {
+      "match": "\\b[0-9]+\\b",
+      "name": "constant.numeric.jsoniq"
+    },
+    {
+      "match": "\\b(NaN|after|allowing|ancestor|ancestor-or-self|and|append|array|as|ascending|at|attribute|base-uri|before|boundary-space|break|by|case|cast|castable|catch|child|collation|comment|constraint|construction|contains|context|continue|copy|copy-namespaces|count|decimal-format|decimal-separator|declare|default|delete|descendant|descendant-or-self|descending|digit|div|document|document-node|element|else|empty|empty-sequence|encoding|end|eq|every|except|exit|external|false|first|following|following-sibling|for|from|ft-option|function|ge|greatest|group|grouping-separator|gt|idiv|if|import|in|index|infinity|insert|instance|integrity|intersect|into|is|item|json|json-item|jsoniq|last|lax|le|least|let|loop|lt|minus-sign|mod|modify|module|namespace|namespace-node|ne|next|node|nodes|not|null|object|of|only|option|or|order|ordered|ordering|paragraphs|parent|pattern-separator|per-mille|percent|preceding|preceding-sibling|previous|processing-instruction|rename|replace|return|returning|revalidation|satisfies|schema|schema-attribute|schema-element|score|select|self|sentences|sliding|some|stable|start|strict|switch|text|then|times|to|treat|true|try|tumbling|type|typeswitch|union|unordered|updating|validate|value|variable|version|when|where|while|window|with|words|xquery|zero-digit)(?!(:|\\-))\\b",
+      "name": "keyword.xquery"
+    },
+    {
+      "comment": "EQName",
+      "match": "([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*:)?([\\-_a-zA-Z0-9][\\-_a-zA-Z0-9]*)(?=\\s*\\()",
+      "name": "support.function.xquery"
+    },
+    {
+      "match": "\\(",
+      "name": "lparen.xquery"
+    },
+    {
+      "match": "\\)",
+      "name": "rparent.xquery"
+    },
+    {
+      "include": "#OpenTag"
+    },
+    {
+      "include": "#CloseTag"
+    }
+  ],
+  "repository": {
+    "OpenTag": {
+      "begin": "<([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*:)?([\\-_a-zA-Z0-9][\\-_a-zA-Z0-9]*)",
+      "end": "(\\/>|>)",
+      "name": "punctuation.definition.tag.xquery",
+      "patterns": [
+        {
+          "match": "([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*:)?([\\-_a-zA-Z0-9][\\-_a-zA-Z0-9]*)",
+          "name": "entity.other.attribute-name.xquery"
+        },
+        {
+          "match": "=",
+          "name": "source.jq"
+        },
+        {
+          "begin": "'",
+          "end": "'(?!')",
+          "name": "string.xquery",
+          "patterns": [
+            {
+              "match": "''",
+              "name": "constant.xquery"
+            },
+            {
+              "include": "#PredefinedEntityRef"
+            },
+            {
+              "include": "#CharRef"
+            },
+            {
+              "match": "({{|}})",
+              "name": "string.xquery"
+            },
+            {
+              "include": "#EnclosedExpr"
+            }
+          ]
+        },
+        {
+          "begin": "\"",
+          "end": "\"(?!\")",
+          "name": "string.xquery",
+          "patterns": [
+            {
+              "match": "\"\"",
+              "name": "constant.xquery"
+            },
+            {
+              "include": "#PredefinedEntityRef"
+            },
+            {
+              "include": "#CharRef"
+            },
+            {
+              "match": "({{|}})",
+              "name": "string.xquery"
+            },
+            {
+              "include": "#EnclosedExpr"
+            }
+          ]
+        }
+      ]
+    },
+    "CloseTag": {
+      "match": "<\\/([\\-_a-zA-Z0-9][\\-\\._a-zA-Z0-9]*:)?([\\-_a-zA-Z0-9][\\-_a-zA-Z0-9]*)>",
+      "name": "punctuation.definition.tag.xquery"
+    },
+    "XMLComment": {
+      "begin": "<!--",
+      "end": "-->",
+      "name": "comment.xquery"
+    },
+    "CDATA": {
+      "begin": "<!\\[CDATA\\[",
+      "end": "\\]\\]>",
+      "name": "constant.language.xquery"
+    },
+    "PredefinedEntityRef": {
+      "match": "&(lt|gt|amp|quot|apos);",
+      "name": "constant.language.escape.xquery"
+    },
+    "CharRef": {
+      "match": "&#([0-9]+|x[0-9A-Fa-f]+);",
+      "name": "constant.language.escape.xquery"
+    },
+    "EnclosedExpr": {
+      "begin": "{",
+      "end": "}",
+      "name": "source.xq",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    }
+  }
+}

data/grammars/source.xquery.json

@@ -0,0 +1,193 @@
+{
+  "fileTypes": [
+    "xq",
+    "xql",
+    "xqm",
+    "xqy",
+    "xquery"
+  ],
+  "firstLineMatch": "^\\bxquery version\\b.*",
+  "foldingStartMarker": "(declare|.*\\{\\s*(//.*)?$)",
+  "foldingStopMarker": "(.*\\}\\s*;?\\s*|.*;)",
+  "keyEquivalent": "^~X",
+  "name": "XQuery",
+  "patterns": [
+    {
+      "match": "^xquery version .*;$",
+      "name": "keyword.control.import.xquery"
+    },
+    {
+      "match": "\\b(?i:(\\d+\\.\\d*(e[\\-\\+]?\\d+)?))(?=[^a-zA-Z_])",
+      "name": "constant.numeric.float.xquery"
+    },
+    {
+      "match": "(?<=[^0-9a-zA-Z_])(?i:(\\.\\d+(e[\\-\\+]?\\d+)?))",
+      "name": "constant.numeric.float.xquery"
+    },
+    {
+      "match": "\\b(?i:(\\d+e[\\-\\+]?\\d+))",
+      "name": "constant.numeric.float.xquery"
+    },
+    {
+      "match": "\\b([1-9]+[0-9]*|0)",
+      "name": "constant.numeric.integer.decimal.xquery"
+    },
+    {
+      "match": "\\b(import|module|schema)\\b",
+      "name": "keyword.control.import.xquery"
+    },
+    {
+      "begin": "\\(:",
+      "captures": {
+        "0": {
+          "name": "punctuation.definition.comment.xquery"
+        }
+      },
+      "end": ":\\)",
+      "name": "comment.block.xquery"
+    },
+    {
+      "comment": "http://www.w3.org/TR/xpath-datamodel/#types",
+      "match": "(?<![:\\-_a-zA-Z0-9])((xs:)(string|boolean|decimal|float|double|duration|dateTime|time|date|gYearMonth|gYear|gMonthDay|gDay|gMonth|hexBinary|base64Binary|anyURI|QName|NOTATION|anyAtomicType|anyType|anySimpleType|untypedAtomic|dayTimeDuration|yearMonthDuration|integer|nonPositiveInteger|negativeInteger|long|int|short|byte|nonNegativeInteger|unsignedLong|unsignedInt|unsignedShort|unsignedByte|positiveInteger|ENTITY|ID|NMTOKEN|language|NCName|Name|token|normalizedString))(?![:\\-_a-zA-Z0-9])",
+      "name": "support.type.xquery"
+    },
+    {
+      "include": "#function_call"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.variable.xquery"
+        }
+      },
+      "match": "((\\$)(?:([\\-_a-zA-Z0-9]+)((:)))?([\\-_a-zA-Z0-9]+))",
+      "name": "variable.other.xquery"
+    },
+    {
+      "match": "/(child|descendant|attribute|self|descendant-or-self|following-sibling|following|parent|ancestor|preceding-sibling|preceding|ancestor-or-self)::",
+      "name": "support.constant.xquery"
+    },
+    {
+      "include": "text.xml"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.xquery"
+        },
+        "2": {
+          "name": "storage.type.function.xquery"
+        },
+        "3": {
+          "name": "entity.name.function.xquery"
+        }
+      },
+      "match": "(declare)\\s+(function)\\s+((?:([\\-_a-zA-Z0-9]+):)?([\\-_a-zA-Z0-9]+))",
+      "name": "meta.function.xquery"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.xquery"
+        },
+        "2": {
+          "name": "storage.type.variable.xquery"
+        }
+      },
+      "match": "(declare)\\s+(variable)",
+      "name": "meta.variable.xquery"
+    },
+    {
+      "match": "\\b(declare|namespace|preserve|no-preserve|inherit|no-inherit|strip|boundary-space|default|instance|option|copy-namespaces)\\b",
+      "name": "keyword.other.prolog.xquery"
+    },
+    {
+      "match": "(?<![:\\-_a-zA-Z0-9])(of|as|by|in|at|or|and)(?![:\\-_a-zA-Z0-9])",
+      "name": "keyword.operator.logical.xquery"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.control.flow.xquery"
+        }
+      },
+      "match": "(?<![:\\-_a-zA-Z0-9])(for|let|return|where|if|then|else|order by|satisfies|every)(?![:\\-_a-zA-Z0-9])"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "support.type.xquery"
+        }
+      },
+      "match": "(?<![:\\-_a-zA-Z0-9])(element|attribute|document-node|schema-element|schema-attribute|processing-instruction|comment|text|node)(?![:\\-_a-zA-Z0-9])"
+    },
+    {
+      "begin": "\"",
+      "end": "\"",
+      "name": "string.quoted.double.xquery"
+    },
+    {
+      "begin": "'",
+      "end": "'",
+      "name": "string.quoted.single.xquery"
+    },
+    {
+      "match": ":=",
+      "name": "keyword.operator.assignment.xquery"
+    },
+    {
+      "match": "(?<![:\\-_a-zA-Z0-9])(\\+|-|<=?|>=?|eq|ne|lt|le|ge|gt|\\*|div|idiv|mod)(?![:\\-_a-zA-Z0-9])",
+      "name": "keyword.operator.arithmetic.xquery"
+    },
+    {
+      "match": "(?<![:\\-_a-zA-Z0-9])((fn:)?(abs|adjust-date-to-timezone|adjust-date-to-timezone|adjust-dateTime-to-timezone|adjust-dateTime-to-timezone|adjust-time-to-timezone|adjust-time-to-timezone|avg|base-uri|base-uri|boolean|ceiling|codepoint-equal|codepoints-to-string|collection|collection|compare|concat|contains|count|current-date|current-dateTime|current-time|data|dateTime|day-from-date|day-from-dateTime|days-from-duration|deep-equal|default-collation|distinct-values|distinct-values|doc|doc-available|document-uri|empty|ends-with|error|escape-uri|exactly-one|exists|false|floor|hours-from-dateTime|hours-from-duration|hours-from-time|id|idref|implicit-timezone|in-scope-prefixes|index-of|insert-before|lang|last|local-name|local-name-from-QName|lower-case|matches|max|min|minutes-from-dateTime|minutes-from-duration|minutes-from-time|month-from-date|month-from-dateTime|months-from-duration|name|namespace-uri|namespace-uri-for-prefix|namespace-uri-from-QName|nilled|node-name|normalize-space|normalize-unicode|not|number|one-or-more|position|prefix-from-QName|QName|remove|replace|resolve-QName|resolve-uri|reverse|root|round|round-half-to-even|seconds-from-dateTime|seconds-from-duration|seconds-from-time|starts-with|static-base-uri|string|string-join|string-length|string-to-codepoints|subsequence|substring|substring-after|substring-before|sum|timezone-from-date|timezone-from-dateTime|timezone-from-time|tokenize|trace|translate|true|unordered|upper-case|year-from-date|year-from-dateTime|years-from-duration|zero-or-one))(?=\\s*\\()",
+      "name": "support.function.builtin.xquery"
+    },
+    {
+      "begin": "(\\()",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.begin.xquery"
+        }
+      },
+      "end": "(\\))",
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.end.xquery"
+        }
+      },
+      "name": "meta",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    }
+  ],
+  "repository": {
+    "function_call": {
+      "begin": "[\\-_a-zA-Z0-9]+:[\\-_a-zA-Z0-9]+(\\()",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.parameters.begin.xquery"
+        }
+      },
+      "end": "(\\))",
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.parameters.end.xquery"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#function_call"
+        },
+        {
+          "include": "$self"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.xquery",
+  "uuid": "5FB86104-E38E-4DAA-B929-DF98011DECBD"
+}

data/grammars/source.xtend.json

@@ -0,0 +1,733 @@
+{
+  "fileTypes": [
+    "xtend"
+  ],
+  "foldingStartMarker": "(\\{\\s*(//.*)?$|^\\s*// \\{\\{\\{)",
+  "foldingStopMarker": "^\\s*(\\}|// \\}\\}\\}$)",
+  "keyEquivalent": "^~J",
+  "name": "Xtend",
+  "patterns": [
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.package.xtend"
+        },
+        "2": {
+          "name": "entity.name.package.xtend"
+        },
+        "3": {
+          "name": "punctuation.terminator.xtend"
+        }
+      },
+      "match": "^\\s*(package)\\b(?:\\s*([^ ;$]+)\\s*(;)?)?",
+      "name": "meta.package.xtend"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.import.xtend"
+        },
+        "2": {
+          "name": "entity.name.package.xtend"
+        },
+        "3": {
+          "name": "punctuation.terminator.xtend"
+        }
+      },
+      "match": "^\\s*(import)\\s+(?:\\s*([^ ;$]+)\\s*(;)?)?$",
+      "name": "meta.import.xtend"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.import.xtend"
+        },
+        "2": {
+          "name": "keyword.other.static.xtend"
+        },
+        "3": {
+          "name": "entity.name.package.xtend"
+        },
+        "4": {
+          "name": "punctuation.terminator.xtend"
+        }
+      },
+      "match": "^\\s*(import)\\s+(static)\\s+(?:\\s*([^ ;$]+)\\s*(;)?)?$",
+      "name": "meta.import.static.xtend"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.import.xtend"
+        },
+        "2": {
+          "name": "keyword.other.static.xtend"
+        },
+        "3": {
+          "name": "variable.language.extension.xtend"
+        },
+        "4": {
+          "name": "entity.name.package.xtend"
+        },
+        "5": {
+          "name": "punctuation.terminator.xtend"
+        }
+      },
+      "match": "^\\s*(import)\\s+(static)\\s+(extension)\\s+(?:\\s*([^ ;$]+)\\s*(;)?)?$",
+      "name": "meta.import.static.extension.xtend"
+    },
+    {
+      "include": "#code"
+    }
+  ],
+  "repository": {
+    "all-types": {
+      "patterns": [
+        {
+          "include": "#primitive-arrays"
+        },
+        {
+          "include": "#primitive-types"
+        },
+        {
+          "include": "#object-types"
+        }
+      ]
+    },
+    "annotations": {
+      "patterns": [
+        {
+          "begin": "(@[^ (]+)(\\()",
+          "beginCaptures": {
+            "1": {
+              "name": "meta.tag.annotation.name.xtend"
+            },
+            "2": {
+              "name": "meta.tag.annotation-arguments.begin.xtend"
+            }
+          },
+          "end": "(\\))",
+          "endCaptures": {
+            "1": {
+              "name": "meta.tag.annotation-arguments.end.xtend"
+            }
+          },
+          "name": "meta.tag.annotation.xtend",
+          "patterns": [
+            {
+              "captures": {
+                "1": {
+                  "name": "constant.other.key.xtend"
+                },
+                "2": {
+                  "name": "keyword.operator.assignment.xtend"
+                }
+              },
+              "match": "(\\w*)\\s*(=)"
+            },
+            {
+              "include": "#code"
+            },
+            {
+              "match": ",",
+              "name": "punctuation.seperator.property.xtend"
+            }
+          ]
+        },
+        {
+          "match": "@\\w*",
+          "name": "meta.tag.annotation.xtend"
+        }
+      ]
+    },
+    "lambdas": {
+      "patterns": [
+        {
+          "match": "(\\[)(?:\\s)",
+          "name": "meta.tag.lambda-start.xtend"
+        },
+        {
+          "match": "(?:\\s)(\\[)",
+          "name": "meta.tag.lambda-end.xtend"
+        }
+      ]
+    },
+    "assertions": {
+      "patterns": [
+        {
+          "begin": "\\b(assert)\\s",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.control.assert.xtend"
+            }
+          },
+          "end": "$",
+          "name": "meta.declaration.assertion.xtend",
+          "patterns": [
+            {
+              "match": ":",
+              "name": "keyword.operator.assert.expression-seperator.xtend"
+            },
+            {
+              "include": "#code"
+            }
+          ]
+        }
+      ]
+    },
+    "class": {
+      "begin": "(?=\\w?[\\w\\s]*(?:class|(?:@)?interface|enum)\\s+\\w+)",
+      "end": "}",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.section.class.end.xtend"
+        }
+      },
+      "name": "meta.class.xtend",
+      "patterns": [
+        {
+          "include": "#storage-modifiers"
+        },
+        {
+          "include": "#comments"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "storage.modifier.xtend"
+            },
+            "2": {
+              "name": "entity.name.type.class.xtend"
+            }
+          },
+          "match": "(class|(?:@)?interface|enum)\\s+(\\w+)",
+          "name": "meta.class.identifier.xtend"
+        },
+        {
+          "begin": "extends",
+          "beginCaptures": {
+            "0": {
+              "name": "storage.modifier.extends.xtend"
+            }
+          },
+          "end": "(?={|implements)",
+          "name": "meta.definition.class.inherited.classes.xtend",
+          "patterns": [
+            {
+              "include": "#object-types-inherited"
+            },
+            {
+              "include": "#comments"
+            }
+          ]
+        },
+        {
+          "begin": "(implements)\\s",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.modifier.implements.xtend"
+            }
+          },
+          "end": "(?=\\s*extends|\\{)",
+          "name": "meta.definition.class.implemented.interfaces.xtend",
+          "patterns": [
+            {
+              "include": "#object-types-inherited"
+            },
+            {
+              "include": "#comments"
+            }
+          ]
+        },
+        {
+          "begin": "{",
+          "end": "(?=})",
+          "name": "meta.class.body.xtend",
+          "patterns": [
+            {
+              "include": "#class-body"
+            }
+          ]
+        }
+      ]
+    },
+    "class-body": {
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#class"
+        },
+        {
+          "include": "#enums"
+        },
+        {
+          "include": "#methods"
+        },
+        {
+          "include": "#annotations"
+        },
+        {
+          "include": "#storage-modifiers"
+        },
+        {
+          "include": "#code"
+        }
+      ]
+    },
+    "code": {
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#class"
+        },
+        {
+          "begin": "{",
+          "end": "}",
+          "patterns": [
+            {
+              "include": "#code"
+            }
+          ]
+        },
+        {
+          "include": "#assertions"
+        },
+        {
+          "include": "#parens"
+        },
+        {
+          "include": "#constants-and-special-vars"
+        },
+        {
+          "include": "#keywords"
+        },
+        {
+          "include": "#storage-modifiers"
+        },
+        {
+          "include": "#strings"
+        },
+        {
+          "include": "#all-types"
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "captures": {
+            "0": {
+              "name": "punctuation.definition.comment.xtend"
+            }
+          },
+          "match": "/\\*\\*/",
+          "name": "comment.block.empty.xtend"
+        },
+        {
+          "include": "text.html.javadoc"
+        },
+        {
+          "include": "#comments-inline"
+        }
+      ]
+    },
+    "comments-inline": {
+      "patterns": [
+        {
+          "begin": "/\\*",
+          "captures": {
+            "0": {
+              "name": "punctuation.definition.comment.xtend"
+            }
+          },
+          "end": "\\*/",
+          "name": "comment.block.xtend"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "comment.line.double-slash.xtend"
+            },
+            "2": {
+              "name": "punctuation.definition.comment.xtend"
+            }
+          },
+          "match": "\\s*((//).*$\\n?)"
+        }
+      ]
+    },
+    "constants-and-special-vars": {
+      "patterns": [
+        {
+          "match": "\\b(true|false|null)\\b",
+          "name": "constant.language.xtend"
+        },
+        {
+          "match": "\\b(this|new|super|it)\\b",
+          "name": "variable.language.xtend"
+        },
+        {
+          "match": "\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)([LlFfUuDd]|UL|ul)?\\b",
+          "name": "constant.numeric.xtend"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.operator.dereference.xtend"
+            }
+          },
+          "match": "(\\.)?\\b([A-Z][A-Z0-9_]+)(?!<|\\.class|\\s*\\w+\\s*=)\\b",
+          "name": "constant.other.xtend"
+        }
+      ]
+    },
+    "enums": {
+      "begin": "^(?=\\s*[A-Z0-9_]+\\s*({|\\(|,))",
+      "end": "(?=;|})",
+      "patterns": [
+        {
+          "begin": "\\w+",
+          "beginCaptures": {
+            "0": {
+              "name": "constant.other.enum.xtend"
+            }
+          },
+          "end": "(?=,|;|})",
+          "name": "meta.enum.xtend",
+          "patterns": [
+            {
+              "include": "#parens"
+            },
+            {
+              "begin": "{",
+              "end": "}",
+              "patterns": [
+                {
+                  "include": "#class-body"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    "keywords": {
+      "patterns": [
+        {
+          "match": "\\b(try|catch|finally|throw)\\b",
+          "name": "keyword.control.catch-exception.xtend"
+        },
+        {
+          "match": "\\?|:",
+          "name": "keyword.control.xtend"
+        },
+        {
+          "match": "\\b(return|break|case|continue|default|do|while|for|switch|if|else)\\b",
+          "name": "keyword.control.xtend"
+        },
+        {
+          "match": "\\b(instanceof)\\b",
+          "name": "keyword.operator.xtend"
+        },
+        {
+          "match": "(==|===|!==|!=|<=|>=|<>|<|>)",
+          "name": "keyword.operator.comparison.xtend"
+        },
+        {
+          "match": "(=)",
+          "name": "keyword.operator.assignment.xtend"
+        },
+        {
+          "match": "(\\-\\-|\\+\\+)",
+          "name": "keyword.operator.increment-decrement.xtend"
+        },
+        {
+          "match": "(\\-|\\+|\\*|\\/|%)",
+          "name": "keyword.operator.arithmetic.xtend"
+        },
+        {
+          "match": "(!|&&|\\|\\|)",
+          "name": "keyword.operator.logical.xtend"
+        },
+        {
+          "match": "(?<=\\S)\\.(?=\\S)",
+          "name": "keyword.operator.dereference.xtend"
+        },
+        {
+          "match": ";",
+          "name": "punctuation.terminator.xtend"
+        }
+      ]
+    },
+    "methods": {
+      "begin": "(def|override)\\s+(?!new)(?=\\w.*\\s+)(?=[^=]+\\()",
+      "beginCaptures": {
+        "1": {
+          "name": "entity.name.function.keyword.xtend"
+        }
+      },
+      "end": "}|(?=;)",
+      "name": "meta.method.xtend",
+      "patterns": [
+        {
+          "include": "#storage-modifiers"
+        },
+        {
+          "begin": "(\\w+)\\s*\\(",
+          "beginCaptures": {
+            "1": {
+              "name": "entity.name.function.xtend"
+            }
+          },
+          "end": "\\)",
+          "name": "meta.method.identifier.xtend",
+          "patterns": [
+            {
+              "include": "#parameters"
+            }
+          ]
+        },
+        {
+          "begin": "(?=\\w.*\\s+\\w+\\s*\\()",
+          "end": "(?=\\w+\\s*\\()",
+          "name": "meta.method.return-type.xtend",
+          "patterns": [
+            {
+              "include": "#all-types"
+            }
+          ]
+        },
+        {
+          "include": "#throws"
+        },
+        {
+          "begin": "{",
+          "end": "(?=})",
+          "name": "meta.method.body.xtend",
+          "patterns": [
+            {
+              "include": "#code"
+            }
+          ]
+        }
+      ]
+    },
+    "object-types": {
+      "patterns": [
+        {
+          "begin": "\\b((?:[a-z]\\w*\\.)*[A-Z]+\\w*)<",
+          "end": ">|[^\\w\\s,\\?<\\[\\]]",
+          "name": "storage.type.generic.xtend",
+          "patterns": [
+            {
+              "include": "#object-types"
+            },
+            {
+              "begin": "<",
+              "comment": "This is just to support <>'s with no actual type prefix",
+              "end": ">|[^\\w\\s,\\[\\]<]",
+              "name": "storage.type.generic.xtend"
+            }
+          ]
+        },
+        {
+          "begin": "\\b((?:[a-z]\\w*\\.)*[A-Z]+\\w*)(?=\\[)",
+          "end": "(?=[^\\]\\s])",
+          "name": "storage.type.object.array.xtend",
+          "patterns": [
+            {
+              "begin": "\\[",
+              "end": "\\]",
+              "patterns": [
+                {
+                  "include": "#code"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.operator.dereference.xtend"
+            }
+          },
+          "match": "\\b(?:[a-z]\\w*(\\.))*[A-Z]+\\w*\\b",
+          "name": "entity.name.type.class.xtend"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.operator.dereference.xtend"
+            }
+          },
+          "match": "^\\s*(\\.)(?=\\w+\\b)",
+          "name": "storage.type.xtend"
+        }
+      ]
+    },
+    "object-types-inherited": {
+      "patterns": [
+        {
+          "begin": "\\b((?:[a-z]\\w*\\.)*[A-Z]+\\w*)<",
+          "end": ">|[^\\w\\s,<]",
+          "name": "entity.other.inherited-class.xtend",
+          "patterns": [
+            {
+              "include": "#object-types"
+            },
+            {
+              "begin": "<",
+              "comment": "This is just to support <>'s with no actual type prefix",
+              "end": ">|[^\\w\\s,<]",
+              "name": "storage.type.generic.xtend"
+            }
+          ]
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.operator.dereference.xtend"
+            }
+          },
+          "match": "\\b(?:[a-z]\\w*(\\.))*[A-Z]+\\w*",
+          "name": "entity.other.inherited-class.xtend"
+        }
+      ]
+    },
+    "parameters": {
+      "patterns": [
+        {
+          "match": "(final|var|val)",
+          "name": "storage.modifier.xtend"
+        },
+        {
+          "include": "#primitive-arrays"
+        },
+        {
+          "include": "#primitive-types"
+        },
+        {
+          "include": "#object-types"
+        },
+        {
+          "match": "\\w+",
+          "name": "variable.parameter.xtend"
+        }
+      ]
+    },
+    "parens": {
+      "begin": "\\(",
+      "end": "\\)",
+      "patterns": [
+        {
+          "include": "#code"
+        }
+      ]
+    },
+    "primitive-arrays": {
+      "patterns": [
+        {
+          "match": "\\b(?:void|boolean|byte|char|short|int|float|long|double)(\\[\\])*\\b",
+          "name": "storage.type.primitive.array.xtend"
+        }
+      ]
+    },
+    "primitive-types": {
+      "patterns": [
+        {
+          "match": "\\b(?:void|boolean|byte|char|short|int|float|long|double)\\b",
+          "name": "storage.type.primitive.xtend"
+        }
+      ]
+    },
+    "storage-modifiers": {
+      "captures": {
+        "1": {
+          "name": "storage.modifier.xtend"
+        }
+      },
+      "match": "\\b(public|private|protected|package|static|var|val|final|native|synchronized|abstract|threadsafe|transient)\\b"
+    },
+    "strings": {
+      "patterns": [
+        {
+          "begin": "\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.xtend"
+            }
+          },
+          "end": "\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.xtend"
+            }
+          },
+          "name": "string.quoted.double.xtend",
+          "patterns": [
+            {
+              "match": "\\\\.",
+              "name": "constant.character.escape.xtend"
+            }
+          ]
+        },
+        {
+          "begin": "'",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.xtend"
+            }
+          },
+          "end": "'",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.xtend"
+            }
+          },
+          "name": "string.quoted.single.xtend",
+          "patterns": [
+            {
+              "match": "\\\\.",
+              "name": "constant.character.escape.xtend"
+            }
+          ]
+        }
+      ]
+    },
+    "throws": {
+      "begin": "throws",
+      "beginCaptures": {
+        "0": {
+          "name": "storage.modifier.xtend"
+        }
+      },
+      "end": "(?={|;)",
+      "name": "meta.throwables.xtend",
+      "patterns": [
+        {
+          "include": "#object-types"
+        }
+      ]
+    },
+    "values": {
+      "patterns": [
+        {
+          "include": "#strings"
+        },
+        {
+          "include": "#object-types"
+        },
+        {
+          "include": "#constants-and-special-vars"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.xtend",
+  "uuid": "2B449DF6-6B1D-11D9-94EC-000D93589AF6"
+}