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,7 @@ const textFragmentExtractors: Record<
     jsonStringTextFragmentExtractor
   ),
   python: constructDefaultTextFragmentExtractor("python"),
+  scala: constructDefaultTextFragmentExtractor("scala"),
   typescript: constructDefaultTextFragmentExtractor(
     "typescript",
     typescriptStringTextFragmentExtractor

src/languages/scala.ts

@@ -0,0 +1,64 @@
+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',
+
+  // lists basic definition is just a function call to a constructor, eg List(1,2,3,4)
+  // MISSING: fancy list style: val foo = 1 :: (2 :: (3 :: Nil)) // List(1,2,3)
+  list: 'call_expression',
+  map: 'call_expression',
+
+  // list.size(), does not count foo.size (field_expression), or foo size (postfix_expression)
+  functionCall: 'call_expression',
+  namedFunction: 'function_definition',
+  // Do we want to consider partial functions as lambdas? eg
+  //   foo.map(_ + 1)
+  //   foo.map {_ + 1}
+  //   foo.map {case x => x + 1}
+  // are not under `lambda_expression`
+  anonymousFunction: 'lambda_expression',
+
+  argumentOrParameter: argumentMatcher('arguments', 'parameters', 'class_parameters', 'bindings'),
+
+  name: ['*[name]', '*[pattern]'],
+  functionName: 'function_definition[name]',
+
+  // MISSING: function/class/trait generics
+  type: leadingMatcher([
+    'generic_type.type_identifier',
+    'type_identifier',
+    'type_parameters',
+  ], [':']),
+  value: leadingMatcher(['*[value]', '*[default_value]'], ['=']),
+  condition: conditionMatcher('*[condition]'),
+
+  // Pulled from the complete list that isn't implemented above
+
+  // collectionItem: "???"
+  // collectionKey: "???",
+
+  // regularExpression: "???",
+
+  // 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/chuckTypeLook.yml

@@ -0,0 +1,29 @@
+languageId: scala
+command:
+  version: 1
+  spokenForm: chuck type look
+  action: remove
+  targets:
+    - type: primitive
+      modifier: {type: containingScope, scopeType: type, includeSiblings: false}
+      mark: {type: decoratedSymbol, symbolColor: default, character: l}
+initialState:
+  documentContents: |
+    class TypesAhoy(foo: List[String]) {}
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks:
+    default.l:
+      start: {line: 0, character: 21}
+      end: {line: 0, character: 25}
+finalState:
+  documentContents: |
+    class TypesAhoy(foo) {}
+  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: l}, selectionType: token, position: contents, insideOutsideType: outside, modifier: {type: containingScope, scopeType: type, includeSiblings: false}, isImplicit: false}]

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

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

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

@@ -0,0 +1,33 @@
+languageId: scala
+command:
+  version: 1
+  spokenForm: chuck type look
+  action: remove
+  targets:
+    - type: primitive
+      modifier: {type: containingScope, scopeType: type, includeSiblings: false}
+      mark: {type: decoratedSymbol, symbolColor: default, character: l}
+initialState:
+  documentContents: |
+    class TypesAhoy() {
+      val foo: List[String] = List("foo")
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks:
+    default.l:
+      start: {line: 1, character: 11}
+      end: {line: 1, character: 15}
+finalState:
+  documentContents: |
+    class TypesAhoy() {
+      val foo = List("foo")
+    }
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  thatMark:
+    - anchor: {line: 1, character: 9}
+      active: {line: 1, character: 9}
+fullTargets: [{type: primitive, mark: {type: decoratedSymbol, symbolColor: default, character: l}, selectionType: token, position: contents, insideOutsideType: outside, modifier: {type: containingScope, scopeType: type, includeSiblings: false}, isImplicit: false}]