Adjust command prompts and improve description of testOnly syntax

Author: biboudis

docs/docs/contributing/eclipse.md

@@ -12,8 +12,8 @@ your Eclipse distribution of choice and enable the Scala IDE from the Eclipse Ma
 1. Clone Dotty's repository from Github (and run `sbt managedSources` as described in 
 [Getting Started](getting-started.md)) 
 2. Generate the Eclipse configuration files:
-```
-sbt eclipse
+```shell
+$ sbt eclipse
 ```
 
 - Note: It is recommended to change the default output folder (in `Properties > java

docs/docs/contributing/getting-started.md

@@ -32,17 +32,17 @@ There are also bash scripts that can be used in the same way. Assuming that you
 the following line on your `.bash_profile`:
 
 ```shell
-export PATH=$HOME/dotty/bin:$PATH
+$ export PATH=$HOME/dotty/bin:$PATH
 ```
 
 and you will be able to run the corresponding commands directly from your console:
 
 ```shell
 # Compile code using Dotty
-dotc tests/pos/HelloWorld.scala
+$ dotc tests/pos/HelloWorld.scala
 
 # Run it with the proper classpath
-dotr HelloWorld
+$ dotr HelloWorld
 ```
 
 

docs/docs/contributing/intellij-idea.md

@@ -8,7 +8,7 @@ Setup
 
 You can setup IntelliJ [IDEA >= 2016.1](https://www.jetbrains.com/idea/nextversion) to run Dotty.
 
-Assuming you have cloned dotty's repository from Github (and run `sbt managedSources` as described in [Getting Started](getting-started.md))
+Assuming you have cloned dotty's repository from Github (and run `sbt managedSources` as described in [Getting Started](getting-started.md)),
 you can now proceed with importing it to IDEA by selecting the
 corresponding option from the startup menu. Navigate on the corresponding directory and select it. Next, you need
 to select the model of the import and as the screenshot shows, select SBT.

docs/docs/contributing/testing.md

@@ -20,38 +20,59 @@ scanning and message errors.
 To run all tests in e.g., for the compiler test-suite you can write:
 
 ```bash
+$ sbt
 > dotty-compiler/test
 ```
 
 To run a single test class you use `testOnly` and the fully qualified class name. 
 For example:
 
 ```bash
-> dotty-compiler/testOnly dotty.tools.dotc.transform.TreeTransformerTest
+> testOnly dotty.tools.dotc.transform.TreeTransformerTest
 ```
 
-You can further restrict the executed tests to a subset of methods by appending ``-- *method_name`` 
-as in the example below:
+The test command follows a regular expression-based syntax `testOnly * -- *`. 
+The right-hand side picks a range of names for methods and the left-hand side picks a range of class names and their
+fully-qualified paths.
+
+Consequently, you can restrict the aforementioned executed test to a subset of methods by appending ``-- *method_name``.
+The example below picks up all methods with the name `canOverwrite`:
+
+```bash
+> testOnly dotty.tools.dotc.transform.TreeTransformerTest -- *canOverwrite
+```
+
+Additionally, you can run all tests named `method_name`, in any class, without providing a class name:
 
 ```bash
-> dotty-compiler/testOnly dotty.tools.dotc.transform.TreeTransformerTest -- *canOverwrite
+> testOnly -- *canOverwrite
+```
+
+You can also run all paths of classes of a certain name:
+
+```bash
+> testOnly *.TreeTransformerTest
 ```
 
 ## Integration tests
 These tests are Scala source files expected to compile with Dotty (pos tests),
 along with their expected output (run tests) or errors (neg tests).
 
-All of these tests are contained in the `./tests/*` directories.
+All of these tests are contained in the `./tests/*` directories and can be run with the `vulpix` command.
 
 Currently to run these tests you need to invoke from sbt:
 
 ```bash
-> testOnly dotty.tools.dotc.CompilationTests
+$ sbt
+> vulpix
 ```
 
-It is also possible to run tests filtered by using the `vulpix` command, again from sbt:
+(which is effectively the same with `testOnly dotty.tools.dotc.CompilationTests`)
+
+It is also possible to run tests filtered, again from sbt:
 
 ```bash
+$ sbt
 > vulpix i2147.scala
 ```
 

docs/docs/contributing/workflow.md

@@ -44,13 +44,14 @@ There is no power mode for the REPL yet, but you can inspect types with the
 type stealer:
 
 ```bash
+$ sbt 
 > repl
 scala> import dotty.tools.DottyTypeStealer._; import dotty.tools.dotc.core._; import Contexts._,Types._
 ```
 
 Now, you can define types and access their representation. For example:
 
-```bash
+```scala
 scala> val s = stealType("class O { type X }", "O#X")
 scala> implicit val ctx: Context = s._1
 scala> val t = s._2(0)