Scala support

data/playground/scala.scala

@@ -0,0 +1,51 @@
+case class Point(x: Int, y: Int)
+
+trait Greeter {
+  def greet(name: String): Unit
+}
+
+class TypesAhoy {
+  def ++[B >: A](suffix: IterableOnce[B]): ArrayBuffer[B] = ???
+  val foo: String = "foo"
+  val bar: List[String] = List("123")
+  bar.map((c: Char) => c.toDigit)
+}
+
+class ExampleClass() {
+  def realFunction() {
+    // Lists
+    val foo: Seq[Int] = List(1,2,3)
+    val fancyList = 1 :: (2 :: (3 :: Nil))
+    foo == fancyList
+
+    // Maps
+    var foo: Map[String, String] = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
+    foo + = ('I' -> 1)
+    foo + = ('J' -> 5)
+    foo + = ('K' -> 10)
+    foo + = ('L' -> 100)
+
+    // lambdas
+    foo.map(a => a + 1)
+    foo.map((a: Int) => a + 1)
+    foo.map(a => {
+      // so many lines!
+      a + 1
+    })
+
+    // partial functions (are they lambdas?)
+    foo.map(_ + 1)
+    foo.map({case x => x + 1})
+
+    // calls with partial functions
+    foo.map(_ + 1) // works
+    foo.map {_ + 1}
+    foo map(_ + 1)
+    foo map {_ + 1}
+    foo.size
+  }
+
+  val xml = <p>Hello</p>
+
+  realFunction(1,2,3)
+}

docs/contributing/adding-a-new-language.md

@@ -11,15 +11,20 @@ for how to add support for a new parser
 
 ## 2. Define parse tree patterns in Cursorless
 
+Minimum changes that each language needs:
+
+- new file in `/src/languages/<yourlanguage>.ts`. Take a look at [existing languages](../../src/languages) as a base. At its core you're implementing your language's version of the `nodeMatchers` const, mapping scope types found in [`Types.ts:ScopeType`](../../src/typings/Types.ts) with matching expressions that align with the parse tree output.
+- new entry in [`getNodeMatcher.ts:languageMatchers`](../../src/languages/getNodeMatcher.ts), importing your new file above
+- new entry in [`constants.ts`](../../src/languages/constants.ts)
+- new text fragment extractor (default is likely fine) in [`getTextFragmentExtractor.ts:textFragmentExtractors`](../../src/languages/getTextFragmentExtractor.ts)
+
 The parse trees exposed by tree-sitter are often pretty close to what we're
 looking for, but we often need to look for specific patterns within the parse
 tree to get the scopes that the user expects. Fortunately, we have a
 domain-specific language that makes these definitions fairly compact.
 
 - Check out the [docs](parse-tree-patterns.md) for the syntax tree pattern
   matcher
-- You may also find it helpful to look at an existing language, such as
-  [java](../../src/languages/java.ts).
 - If you look in the debug console, you'll see debug output every time you move
   your cursor, which might be helpful.
 - You will likely want to look at `node-types.json` for your language, (eg [java](https://github.com/tree-sitter/tree-sitter-java/blob/master/src/node-types.json)). This file is generated from `grammar.js`, which might also be helpful to look at (eg [java](https://github.com/tree-sitter/tree-sitter-java/blob/master/grammar.js)).

src/languages/constants.ts

@@ -11,6 +11,7 @@ export const supportedLanguageIds = [
   "json",
   "jsonc",
   "python",
+  "scala",
   "typescript",
   "typescriptreact",
 ] as const;

src/languages/getNodeMatcher.ts

@@ -15,6 +15,7 @@ import { patternMatchers as typescript } from "./typescript";
 import java from "./java";
 import { patternMatchers as html } from "./html";
 import python from "./python";
+import scala from "./scala";
 import go from "./go";
 import { UnsupportedLanguageError } from "../errors";
 import { SupportedLanguageId } from "./constants";
@@ -59,6 +60,7 @@ const languageMatchers: Record<
   json,
   jsonc: json,
   python,
+  scala,
   typescript,
   typescriptreact: typescript,
 };

src/languages/getTextFragmentExtractor.ts

@@ -149,6 +149,10 @@ const textFragmentExtractors: Record<
     jsonStringTextFragmentExtractor
   ),
   python: constructDefaultTextFragmentExtractor("python"),
+  scala: constructDefaultTextFragmentExtractor(
+    "scala",
+    constructHackedStringTextFragmentExtractor("scala")
+  ),
   typescript: constructDefaultTextFragmentExtractor(
     "typescript",
     typescriptStringTextFragmentExtractor

src/languages/scala.ts

@@ -0,0 +1,84 @@
+import {
+  createPatternMatchers,
+  argumentMatcher,
+  leadingMatcher,
+  conditionMatcher,
+  trailingMatcher,
+  cascadingMatcher,
+} from '../util/nodeMatchers';
+import { NodeMatcherAlternative, ScopeType } from '../typings/Types';
+
+const nodeMatchers: Partial<Record<ScopeType, NodeMatcherAlternative>> = {
+  // treating classes = classlike
+  class: ['class_definition', 'object_definition', 'trait_definition'],
+  className: ['class_definition[name]', 'object_definition[name]', 'trait_definition[name]'],
+
+  ifStatement: 'if_expression',
+
+  string: ['interpolated_string_expression', 'string'],
+  comment: 'comment',
+
+  // list.size(), does not count foo.size (field_expression), or foo size (postfix_expression)
+  functionCall: 'call_expression',
+  namedFunction: 'function_definition',
+  anonymousFunction: 'lambda_expression',
+
+  argumentOrParameter: argumentMatcher('arguments', 'parameters', 'class_parameters', 'bindings'),
+
+  name: ['*[name]', '*[pattern]'],
+  functionName: 'function_definition[name]',
+
+  // *[type] does not work here because while we want most of these we don't want "compound" types,
+  // eg `generic_type[type]`, because that will grab just the inner generic (the String of List[String])
+  // and as a rule we want to grab entire type definitions.
+  type: leadingMatcher([
+    'upper_bound[type]',
+    'lower_bound[type]',
+    'view_bound[type]',
+    'context_bound[type]',
+    'val_definition[type]',
+    'val_declaration[type]',
+    'var_definition[type]',
+    'var_declaration[type]',
+    'type_definition',
+    'extends_clause[type]',
+    'class_parameter[type]',
+    'parameter[type]',
+    'function_definition[return_type]',
+    'typed_pattern[type]',
+    'binding[type]',
+  ], [':']),
+  value: leadingMatcher(['*[value]', '*[default_value]', 'type_definition[type]'], ['=']),
+  condition: conditionMatcher('*[condition]'),
+
+  // Scala features unsupported in Cursorless terminology
+  //  - Pattern matching
+
+  // Cursorless terminology not yet supported in this Scala implementation
+  /*
+    lists and maps basic definition are just function calls to constructors, eg List(1,2,3,4)
+    These types are also basically arbitrary, so we can't really hard-code them
+    There is also fancy list style: val foo = 1 :: (2 :: (3 :: Nil)) // List(1,2,3)
+  */
+  // list: 'call_expression',
+  // map: 'call_expression',
+
+  /* infix_expression, key on left, item on right, operator = "->"
+  // collectionItem: "???"
+  // collectionKey: "???",
+
+  /* "foo".r <-, value of type field_expression, value of type string, field of type identifier = "r",
+  // regularExpression: "???",
+
+  /*
+    none of this stuff is defined well in the tree sitter (it's all just infix expressions etc),
+    and native XML/HTML is deprecated in Scala 3
+  */
+  // attribute: "???",
+  // xmlElement: "???",
+  // xmlStartTag: "???",
+  // xmlEndTag: "???",
+  // xmlBothTags: "???",
+};
+
+export default createPatternMatchers(nodeMatchers);

src/test/runTest.ts

@@ -7,7 +7,11 @@ import {
   downloadAndUnzipVSCode,
 } from "vscode-test";
 
-const extensionDependencies = ["pokey.parse-tree", "ms-toolsai.jupyter"];
+const extensionDependencies = [
+  "pokey.parse-tree",
+  "ms-toolsai.jupyter",
+  "scalameta.metals",
+];
 
 async function main() {
   try {

src/test/suite/fixtures/recorded/languages/scala/chuckArgFine.yml

@@ -0,0 +1,29 @@
+languageId: scala
+command:
+  version: 1
+  spokenForm: chuck arg fine
+  action: remove
+  targets:
+    - type: primitive
+      modifier: {type: containingScope, scopeType: argumentOrParameter, includeSiblings: false}
+      mark: {type: decoratedSymbol, symbolColor: default, character: f}
+initialState:
+  documentContents: |
+    class ExampleClass(foo: Int, bar: Int) {}
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks:
+    default.f:
+      start: {line: 0, character: 19}
+      end: {line: 0, character: 22}
+finalState:
+  documentContents: |
+    class ExampleClass(bar: Int) {}
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  thatMark:
+    - anchor: {line: 0, character: 19}
+      active: {line: 0, character: 19}
+fullTargets: [{type: primitive, mark: {type: decoratedSymbol, symbolColor: default, character: f}, selectionType: token, position: contents, insideOutsideType: outside, modifier: {type: containingScope, scopeType: argumentOrParameter, includeSiblings: false}, isImplicit: false}]

src/test/suite/fixtures/recorded/languages/scala/chuckArgFine2.yml

@@ -0,0 +1,33 @@
+languageId: scala
+command:
+  version: 1
+  spokenForm: chuck arg fine
+  action: remove
+  targets:
+    - type: primitive
+      modifier: {type: containingScope, scopeType: argumentOrParameter, includeSiblings: false}
+      mark: {type: decoratedSymbol, symbolColor: default, character: f}
+initialState:
+  documentContents: |
+    class ExampleClass() {
+      def example(foo: Int, bar: Int) = foo + bar
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks:
+    default.f:
+      start: {line: 1, character: 14}
+      end: {line: 1, character: 17}
+finalState:
+  documentContents: |
+    class ExampleClass() {
+      def example(bar: Int) = foo + bar
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  thatMark:
+    - anchor: {line: 1, character: 14}
+      active: {line: 1, character: 14}
+fullTargets: [{type: primitive, mark: {type: decoratedSymbol, symbolColor: default, character: f}, selectionType: token, position: contents, insideOutsideType: outside, modifier: {type: containingScope, scopeType: argumentOrParameter, includeSiblings: false}, isImplicit: false}]

src/test/suite/fixtures/recorded/languages/scala/chuckArgFine3.yml

@@ -0,0 +1,33 @@
+languageId: scala
+command:
+  version: 1
+  spokenForm: chuck arg fine
+  action: remove
+  targets:
+    - type: primitive
+      modifier: {type: containingScope, scopeType: argumentOrParameter, includeSiblings: false}
+      mark: {type: decoratedSymbol, symbolColor: default, character: f}
+initialState:
+  documentContents: |
+    class ExampleClass() {
+      example(foo, bar)
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks:
+    default.f:
+      start: {line: 1, character: 10}
+      end: {line: 1, character: 13}
+finalState:
+  documentContents: |
+    class ExampleClass() {
+      example(bar)
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  thatMark:
+    - anchor: {line: 1, character: 10}
+      active: {line: 1, character: 10}
+fullTargets: [{type: primitive, mark: {type: decoratedSymbol, symbolColor: default, character: f}, selectionType: token, position: contents, insideOutsideType: outside, modifier: {type: containingScope, scopeType: argumentOrParameter, includeSiblings: false}, isImplicit: false}]

src/test/suite/fixtures/recorded/languages/scala/chuckConditionFine.yml

@@ -0,0 +1,33 @@
+languageId: scala
+command:
+  version: 1
+  spokenForm: chuck condition fine
+  action: remove
+  targets:
+    - type: primitive
+      modifier: {type: containingScope, scopeType: condition, includeSiblings: false}
+      mark: {type: decoratedSymbol, symbolColor: default, character: f}
+initialState:
+  documentContents: |-
+    class Example() {
+      if (1 + 2 == 3) println("wow")
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks:
+    default.f:
+      start: {line: 1, character: 2}
+      end: {line: 1, character: 4}
+finalState:
+  documentContents: |-
+    class Example() {
+      if () println("wow")
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  thatMark:
+    - anchor: {line: 1, character: 6}
+      active: {line: 1, character: 6}
+fullTargets: [{type: primitive, mark: {type: decoratedSymbol, symbolColor: default, character: f}, selectionType: token, position: contents, insideOutsideType: outside, modifier: {type: containingScope, scopeType: condition, includeSiblings: false}, isImplicit: false}]

src/test/suite/fixtures/recorded/languages/scala/chuckTypeBat.yml

@@ -0,0 +1,33 @@
+languageId: scala
+command:
+  version: 1
+  spokenForm: chuck type bat
+  action: remove
+  targets:
+    - type: primitive
+      modifier: {type: containingScope, scopeType: type, includeSiblings: false}
+      mark: {type: decoratedSymbol, symbolColor: default, character: b}
+initialState:
+  documentContents: |-
+    class Example(foo: String) {
+      def str(bar: String): String = foo + bar
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks:
+    default.b:
+      start: {line: 1, character: 10}
+      end: {line: 1, character: 13}
+finalState:
+  documentContents: |-
+    class Example(foo: String) {
+      def str(bar): String = foo + bar
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  thatMark:
+    - anchor: {line: 1, character: 13}
+      active: {line: 1, character: 13}
+fullTargets: [{type: primitive, mark: {type: decoratedSymbol, symbolColor: default, character: b}, selectionType: token, position: contents, insideOutsideType: outside, modifier: {type: containingScope, scopeType: type, includeSiblings: false}, isImplicit: false}]