From 90c6c611991fff9ac77fc616a6c94111aa3585b2 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Tue, 3 Oct 2017 18:19:25 -0400 Subject: [PATCH 1/2] Add Scala syntax from daltonjorge/vscode-scala This adds Scala syntax for VS Code. The current plugin was relying on daltonjorge/vscode-scala for detecting that `*.scala` is a Scala source. This change integrates the plugin into this one. daltonjorge/vscode-scala is licensed under MIT license. --- .../client/language-configuration.json | 30 + vscode-sbt-scala/client/package.json | 25 +- .../client/syntaxes/Scala.tmLanguage | 1262 +++++++++++++++++ 3 files changed, 1316 insertions(+), 1 deletion(-) create mode 100644 vscode-sbt-scala/client/language-configuration.json create mode 100644 vscode-sbt-scala/client/syntaxes/Scala.tmLanguage diff --git a/vscode-sbt-scala/client/language-configuration.json b/vscode-sbt-scala/client/language-configuration.json new file mode 100644 index 000000000..aa2571000 --- /dev/null +++ b/vscode-sbt-scala/client/language-configuration.json @@ -0,0 +1,30 @@ +{ + "comments": { + // symbol used for single line comment. Remove this entry if your language does not support line comments + "lineComment": "//", + // symbols used for start and end a block comment. Remove this entry if your language does not support block comments + "blockComment": [ "/*", "*/" ] + }, + // symbols used as brackets + "brackets": [ + ["{", "}"], + ["[", "]"], + ["(", ")"] + ], + // symbols that are auto closed when typing + "autoClosingPairs": [ + ["{", "}"], + ["[", "]"], + ["(", ")"], + ["\"", "\""], + ["'", "'"] + ], + // symbols that that can be used to surround a selection + "surroundingPairs": [ + ["{", "}"], + ["[", "]"], + ["(", ")"], + ["\"", "\""], + ["'", "'"] + ] +} \ No newline at end of file diff --git a/vscode-sbt-scala/client/package.json b/vscode-sbt-scala/client/package.json index 7f1760155..fa56b2102 100644 --- a/vscode-sbt-scala/client/package.json +++ b/vscode-sbt-scala/client/package.json @@ -1,7 +1,7 @@ { "name": "vscode-sbt-scala", "displayName": "Scala (sbt)", - "version": "0.0.1", + "version": "0.0.2", "author": "Lightbend, Inc.", "license": "BSD-3-Clause", "publisher": "lightbend", @@ -17,6 +17,29 @@ "categories": [ "Languages" ], + "contributes": { + "languages": [ + { + "id": "scala", + "aliases": [ + "Scala", + "scala" + ], + "extensions": [ + ".scala", + ".sbt" + ], + "configuration": "./language-configuration.json" + } + ], + "grammars": [ + { + "language": "scala", + "scopeName": "source.scala", + "path": "./syntaxes/Scala.tmLanguage" + } + ] + }, "activationEvents": [ "workspaceContains:build.sbt" ], diff --git a/vscode-sbt-scala/client/syntaxes/Scala.tmLanguage b/vscode-sbt-scala/client/syntaxes/Scala.tmLanguage new file mode 100644 index 000000000..2dc4860cd --- /dev/null +++ b/vscode-sbt-scala/client/syntaxes/Scala.tmLanguage @@ -0,0 +1,1262 @@ + + + + + fileTypes + + scala + + firstLineMatch + ^#!/.*\b\w*scala\b + foldingStartMarker + /\*\*|\{\s*$ + foldingStopMarker + \*\*/|^\s*\} + keyEquivalent + ^~S + name + Scala + patterns + + + include + #code + + + repository + + block-comments + + begin + /\* + end + \*/ + name + comment.block.scala + patterns + + + include + #block-comments + + + match + (?x) + (?! /\*) + (?! \*/) + + + + + char-literal + + begin + ' + beginCaptures + + 0 + + name + punctuation.definition.character.begin.scala + + + end + ' + endCaptures + + 0 + + name + punctuation.definition.character.end.scala + + + name + constant.character.literal.scala + patterns + + + match + \\(?:[btnfr\\"']|[0-7]{1,3}|u[0-9A-Fa-f]{4}) + name + constant.character.escape.scala + + + match + \\. + name + invalid.illegal.unrecognized-character-escape.scala + + + match + [^']{2,} + name + invalid.illegal.character-literal-too-long + + + match + (?<!')[^'] + name + invalid.illegal.character-literal-too-long + + + + code + + patterns + + + include + #script-header + + + include + #storage-modifiers + + + include + #declarations + + + include + #inheritance + + + include + #imports + + + include + #comments + + + include + #strings + + + include + #initialization + + + include + #xml-literal + + + include + #keywords + + + include + #constants + + + include + #scala-symbol + + + include + #special-identifier + + + include + #char-literal + + + include + #empty-parentheses + + + include + #parameter-list + + + include + #qualifiedClassName + + + include + #meta-brackets + + + include + #meta-bounds + + + include + #meta-colons + + + + comments + + patterns + + + captures + + 0 + + name + punctuation.definition.comment.scala + + + match + /\*\*/ + name + comment.block.empty.scala + + + begin + ^\s*(/\*\*)(?!/) + beginCaptures + + 1 + + name + punctuation.definition.comment.scala + + + end + \*/ + endCaptures + + 0 + + name + punctuation.definition.comment.scala + + + name + comment.block.documentation.scala + patterns + + + captures + + 1 + + name + keyword.other.documentation.scaladoc.scala + + 2 + + name + variable.parameter.scala + + + match + (@param)\s+(\S+) + + + captures + + 1 + + name + keyword.other.documentation.scaladoc.scala + + 2 + + name + entity.name.class + + + match + (@(?:tparam|throws))\s+(\S+) + + + match + @(return|see|note|example|usecase|author|version|since|todo|deprecated|migration|define|inheritdoc)\b + name + keyword.other.documentation.scaladoc.scala + + + captures + + 1 + + name + punctuation.definition.documentation.link.scala + + 2 + + name + entity.other.documentation.link.scala + + 3 + + name + punctuation.definition.documentation.link.scala + + + match + (\[\[)([^\]]+)(\]\]) + + + + + begin + /\* + captures + + 0 + + name + punctuation.definition.comment.scala + + + end + \*/ + name + comment.block.scala + + + begin + (^[ \t]+)?(?=//) + beginCaptures + + 1 + + name + punctuation.whitespace.comment.leading.scala + + + end + (?!\G) + patterns + + + begin + // + beginCaptures + + 0 + + name + punctuation.definition.comment.scala + + + end + \n + name + comment.line.double-slash.scala + + + + + + constants + + patterns + + + match + \b(false|null|true|Nil|None)\b + name + constant.language.scala + + + match + \b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.[0-9]+)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?|[0-9]+)([LlFfDd]|UL|ul)?\b + name + constant.numeric.scala + + + match + \b(this|super|self)\b + name + variable.language.scala + + + match + \b(Unit|Boolean|Byte|Char|Short|Int|Float|Long|Double)\b + name + storage.type.primitive.scala + + + match + \b(String|Symbol)\b + name + storage.type.scala + + + + declarations + + patterns + + + captures + + 1 + + name + keyword.declaration.scala + + 2 + + name + entity.name.function.declaration + + + match + (?x) + \b(def)\s+ + (`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*(?:_[^\t .,;()\[\]{}'"`\w])(?=[(\t ])|[_$a-zA-Z][_$a-zA-Z0-9]*|[-?~><^+*%:!#|/@\\]+) + + + captures + + 1 + + name + keyword.declaration.scala + + 2 + + name + keyword.declaration.scala + + 3 + + name + entity.name.class.declaration + + + match + (case)?\b(class|trait|object)\s+([^\s\{\(\[]+) + + + captures + + 1 + + name + keyword.declaration.scala + + 2 + + name + entity.name.type.declaration + + + match + \b(type)\s+(`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*(?:_[^\s])(?=[\t ])|[_$a-zA-Z][_$a-zA-Z0-9]*|[-?~><^+*%:!#|/@\\]+) + + + captures + + 1 + + name + keyword.declaration.stable.scala + + 2 + + name + constant.other.declaration.scala + + + match + \b(val)\s+(?:([A-Z][_a-zA-Z0-9]*))\b + + + captures + + 1 + + name + keyword.declaration.stable.scala + + 2 + + name + keyword.declaration.volatile.scala + + 3 + + name + variable.other.declaration.scala + + + match + \b(?:(val)|(var))\s+(?:(`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*(?:_[^\t .,;()\[\]{}'"`\w])(?=[\t ])|[_$a-zA-Z][_$a-zA-Z0-9]*|[-?~><^+*%:!#|/@\\]+)|(?=\()) + + + captures + + 1 + + name + keyword.other.scoping.scala + + 2 + + name + keyword.declaration.scala + + 3 + + name + entity.name.class.declaration + + + match + \b(package)\s+(object)\s+([^\s\{\(\[]+) + + + begin + \b(package)\s+ + beginCaptures + + 1 + + name + keyword.other.import.scala + + + end + (?<=[\n;]) + name + meta.package.scala + patterns + + + include + #comments + + + match + (`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*) + name + entity.name.package.scala + + + match + \. + name + punctuation.definition.package + + + + + + empty-parentheses + + captures + + 1 + + name + meta.bracket.scala + + + match + (\(\)) + name + meta.parentheses.scala + + imports + + begin + \b(import)\s+ + beginCaptures + + 1 + + name + keyword.other.import.scala + + + end + (?<=[\n;]) + name + meta.import.scala + patterns + + + include + #comments + + + match + (`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*) + name + entity.name.import.scala + + + match + \. + name + punctuation.definition.import + + + begin + { + beginCaptures + + 0 + + name + meta.bracket.scala + + + end + } + endCaptures + + 0 + + name + meta.bracket.scala + + + name + meta.import.selector.scala + patterns + + + captures + + 1 + + name + entity.name.import.renamed-from.scala + + 2 + + name + keyword.other.arrow.scala + + 3 + + name + entity.name.import.renamed-to.scala + + + match + (?x) \s* + (`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*) \s* + (=>) \s* + (`[^`]+`|[_$a-zA-Z][_$a-zA-Z0-9]*) \s* + + + + match + ([^\s.,}]+) + name + entity.name.import.scala + + + + + + inheritance + + patterns + + + captures + + 1 + + name + keyword.declaration.scala + + 2 + + name + entity.other.inherited-class.scala + + + match + (extends|with)\s+([^\s\{\(\[\]]+) + + + + initialization + + captures + + 1 + + name + keyword.declaration.scala + + 2 + + name + entity.name.class + + + match + \b(new)\s+([^\s,\{\}\(\)\[\]]+) + + keywords + + patterns + + + match + \b(return|throw)\b + name + keyword.control.flow.jump.scala + + + match + \b(classOf|isInstanceOf|asInstanceOf)\b + name + support.function.type-of.scala + + + match + \b(else|if|do|while|for|yield|match|case)\b + name + keyword.control.flow.scala + + + match + \b(catch|finally|try)\b + name + keyword.control.exception.scala + + + match + (==?|!=|<=|>=|<>|<|>) + name + keyword.operator.comparison.scala + + + match + (\-|\+|\*|/(?![/*])|%|~) + name + keyword.operator.arithmetic.scala + + + match + (!|&&|\|\|) + name + keyword.operator.logical.scala + + + match + (<-|←|->|→|=>|⇒|\?|\:+|@|\|)+ + name + keyword.operator.scala + + + + meta-bounds + + comment + For themes: Matching view bounds + match + <%|=:=|<:<|<%<|>:|<: + name + meta.bounds.scala + + meta-brackets + + comment + For themes: Brackets look nice when colored. + patterns + + + comment + The punctuation.section.*.begin is needed for return snippet in source bundle + match + \{ + name + punctuation.section.block.begin.scala + + + comment + The punctuation.section.*.end is needed for return snippet in source bundle + match + \} + name + punctuation.section.block.end.scala + + + match + {|}|\(|\)|\[|\] + name + meta.bracket.scala + + + + meta-colons + + comment + For themes: Matching type colons + patterns + + + match + (?<!:):(?!:) + name + meta.colon.scala + + + + parameter-list + + patterns + + + captures + + 1 + + name + variable.parameter.scala + + 2 + + name + meta.colon.scala + + + comment + We do not match param names that start with a Capitol letter + match + (?<=[^\._$a-zA-Z0-9])(`[^`]+`|[_$a-z][_$a-zA-Z0-9]*(?:_[^\s])(?=[\t ])|[_$a-z][_$a-zA-Z0-9]*|[-?~><^+*%:!#|/@\\]+)\s*(:)\s+ + + + + qualifiedClassName + + captures + + 1 + + name + entity.name.class + + + match + (\b([A-Z][\w]*)) + + scala-symbol + + match + '\w+(?=[^'\w]|$) + name + constant.other.symbol.scala + + script-header + + captures + + 1 + + name + string.unquoted.shebang.scala + + + match + ^#!(.*)$ + name + comment.block.shebang.scala + + special-identifier + + comment + + Match special scala style identifiers that can end with and underscore and + a a not letter such as blank_?. This way the symbol will not be colored + differently. + + match + \b[_$a-zA-Z][_$a-zA-Z0-9]*(?:_[^\t .,;()\[\]{}'"`\w]) + + storage-modifiers + + patterns + + + match + \b(private\[\S+\]|protected\[\S+\]|private|protected)\b + name + storage.modifier.access + + + match + \b(synchronized|@volatile|abstract|final|lazy|sealed|implicit|override|@transient|@native)\b + name + storage.modifier.other + + + + strings + + patterns + + + begin + """ + beginCaptures + + 0 + + name + punctuation.definition.string.begin.scala + + + end + """(?!") + endCaptures + + 0 + + name + punctuation.definition.string.end.scala + + + name + string.quoted.triple.scala + patterns + + + match + \\\\|\\u[0-9A-Fa-f]{4} + name + constant.character.escape.scala + + + + + begin + " + beginCaptures + + 0 + + name + punctuation.definition.string.begin.scala + + + end + " + endCaptures + + 0 + + name + punctuation.definition.string.end.scala + + + name + string.quoted.double.scala + patterns + + + match + \\(?:[btnfr\\"']|[0-7]{1,3}|u[0-9A-Fa-f]{4}) + name + constant.character.escape.scala + + + match + \\. + name + invalid.illegal.unrecognized-string-escape.scala + + + + + + xml-doublequotedString + + begin + " + beginCaptures + + 0 + + name + punctuation.definition.string.begin.xml + + + end + " + endCaptures + + 0 + + name + punctuation.definition.string.end.xml + + + name + string.quoted.double.xml + patterns + + + include + #xml-entity + + + + xml-embedded-content + + patterns + + + begin + { + captures + + 0 + + name + meta.bracket.scala + + + end + } + name + meta.source.embedded.scala + patterns + + + include + #code + + + + + captures + + 1 + + name + entity.other.attribute-name.namespace.xml + + 2 + + name + entity.other.attribute-name.xml + + 3 + + name + punctuation.separator.namespace.xml + + 4 + + name + entity.other.attribute-name.localname.xml + + + match + (?:([-_a-zA-Z0-9]+)((:)))?([_a-zA-Z-]+)= + + + include + #xml-doublequotedString + + + include + #xml-singlequotedString + + + + xml-entity + + captures + + 1 + + name + punctuation.definition.constant.xml + + 3 + + name + punctuation.definition.constant.xml + + + match + (&)([:a-zA-Z_][:a-zA-Z0-9_.-]*|#[0-9]+|#x[0-9a-fA-F]+)(;) + name + constant.character.entity.xml + + xml-literal + + patterns + + + begin + (<)((?:([_a-zA-Z0-9][_a-zA-Z0-9]*)((:)))?([_a-zA-Z0-9][-_a-zA-Z0-9:]*))(?=(\s[^>]*)?></\2>) + beginCaptures + + 1 + + name + punctuation.definition.tag.xml + + 3 + + name + entity.name.tag.namespace.xml + + 4 + + name + entity.name.tag.xml + + 5 + + name + punctuation.separator.namespace.xml + + 6 + + name + entity.name.tag.localname.xml + + + comment + We do not allow a tag name to start with a - since this would + likely conflict with the <- operator. This is not very common + for tag names anyway. Also code such as -- if (val <val2 || val> val3) + will falsly be recognized as an xml tag. The solution is to put a + space on either side of the comparison operator + end + (>(<))/(?:([-_a-zA-Z0-9]+)((:)))?([-_a-zA-Z0-9:]*[_a-zA-Z0-9])(>) + endCaptures + + 1 + + name + punctuation.definition.tag.xml + + 2 + + name + meta.scope.between-tag-pair.xml + + 3 + + name + entity.name.tag.namespace.xml + + 4 + + name + entity.name.tag.xml + + 5 + + name + punctuation.separator.namespace.xml + + 6 + + name + entity.name.tag.localname.xml + + 7 + + name + punctuation.definition.tag.xml + + + name + meta.tag.no-content.xml + patterns + + + include + #xml-embedded-content + + + + + begin + (</?)(?:([_a-zA-Z0-9][-_a-zA-Z0-9]*)((:)))?([_a-zA-Z0-9][-_a-zA-Z0-9:]*)(?=[^>]*?>) + captures + + 1 + + name + punctuation.definition.tag.xml + + 2 + + name + entity.name.tag.namespace.xml + + 3 + + name + entity.name.tag.xml + + 4 + + name + punctuation.separator.namespace.xml + + 5 + + name + entity.name.tag.localname.xml + + + end + (/?>) + name + meta.tag.xml + patterns + + + include + #xml-embedded-content + + + + + include + #xml-entity + + + + xml-singlequotedString + + begin + ' + beginCaptures + + 0 + + name + punctuation.definition.string.begin.xml + + + end + ' + endCaptures + + 0 + + name + punctuation.definition.string.end.xml + + + name + string.quoted.single.xml + patterns + + + include + #xml-entity + + + + + scopeName + source.scala + uuid + 158C0929-299A-40C8-8D89-316BE0C446E8 + + From 10539bcd22dc1da135b3ef4e7929580745b67b70 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Tue, 3 Oct 2017 18:22:14 -0400 Subject: [PATCH 2/2] update logo to a white background version --- .../client/images/sbt-logo-455x262.png | Bin 6715 -> 0 bytes .../client/images/sbt-logo-bgwhite-455x262.png | Bin 0 -> 7859 bytes vscode-sbt-scala/client/package.json | 2 +- 3 files changed, 1 insertion(+), 1 deletion(-) delete mode 100644 vscode-sbt-scala/client/images/sbt-logo-455x262.png create mode 100644 vscode-sbt-scala/client/images/sbt-logo-bgwhite-455x262.png diff --git a/vscode-sbt-scala/client/images/sbt-logo-455x262.png b/vscode-sbt-scala/client/images/sbt-logo-455x262.png deleted file mode 100644 index 82f485ef9692ede8f09d296bce9df0ae9c23aa80..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6715 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 literal 0 HcmV?d00001 diff --git a/vscode-sbt-scala/client/package.json b/vscode-sbt-scala/client/package.json index fa56b2102..d42177c0a 100644 --- a/vscode-sbt-scala/client/package.json +++ b/vscode-sbt-scala/client/package.json @@ -10,7 +10,7 @@ "url": "https://github.com/sbt/sbt" }, "description": "Scala language support using sbt", - "icon": "images/sbt-logo-455x262.png", + "icon": "images/sbt-logo-bgwhite-455x262.png", "engines": { "vscode": "^1.16.0" },