scala-ide/scala-worksheet

A Scala IDE plugin for a multi-line REPL (called worksheet)

Scala Worksheet plugin for Eclipse

A simple worksheet implementation for Scala IDE. It is a glorified editor, with the option of evaluating the script and placing the results of each expression in a comment on the same line.

There are 5 Eclipse plugins:

• the plugin itself
• the plugin.tests fragment
• the plugin's runtime library (needed for producing the worksheet's output)
• an Eclipse feature
• an Eclipse source feature
• an Eclipse update-site

The projects can readily be imported inside Eclipse. Additionally, you have maven pom files based on Tycho, enabling command line builds.

Download:

• Released version: Included in each of the available milestone update-sites
• Nightly update site: 4.0.x-2.10.x, 4.0.x-2.11.x and 3.0.x-2.10.x

Build

Simply run the ./build.sh script.

The worksheet build is based on plugin-profiles and can be built against several versions of the IDE, Eclipse and Scala compiler.

Launching the build.sh script will exand to the following Maven command:

mvn -Peclipse-indigo,scala-2.10.x,scala-ide-stable clean install

You can choose a different profile for any of the three axis: eclipse platform, Scala version and Scala IDE stream. Read here for more details.

scala-worksheet's Issues

Ask for build before evalute

If the project is not up to date, evaluating the worksheet may trigger compilation errors. On the other hand, the worksheet may not depend on any types in the project, so it would be ok to evaluate.

Ask the user!

After evaluating, syntax coloring is not correct

Whenever a new line is added to the source file, after evaluating, the syntax colors for previous code, will be disabled.

`Evaluate Worksheet` on each save

Instead of having the user explicitly call the eval action, have an option to automatically evaluate on each save.

Instrumented sources should not be stored in Eclipse installation

Currently, the $instrumented.scala sources are stored in the Eclipse installation, i.e. inside Eclipse.app/Contents/MacOS/. Not really the ideal place ;-)

Also, the binaries are placed in the project's binary folder. I think what we can do is creating a .instrumented/src and .instrumented/bin in the project's root and store sources and binaries for the worksheet there.

Report build errors in the Eclipse Problems View

Evaluating the following snippet won't work because it contains a compilation error. However, no error is reported in the editor because unimplemented abstract methods are only checked during refcheck phase, which is not run by the presentation compiler.

object Main {
  abstract class A {
    def foo: Unit
  }
  class B extends A

  new B
}

What we need to do is pass an instance of BuildReporter to the Global use to compile the worksheets, so that build errors are always reported in the Problems View.

Scala 2.9 support

After chatting with Lukas and Josh, it looks like 2.9 support is extremely important for the worksheet.

Move SourceInserter and Mixer sources from scala-compiler

SourceInserter.scala and Mixer.scala should be moved from the scala-compiler project in the worksheet project (there is no reason for them to be in the compiler side)

'askReload' using a Document Listener

Right now we do askReload on document reconciliation, which is pooling changes the moment the user stops typing for a few milliseconds.

This has the advantage of not generating useless work, but if the user is very fast, he can ask for completions before the reconciler has kicked in. This means that ASTs are out of date, and completion will return, say, scope completion instead of members (because the old AST does not have the 'Select' node yet).

We should move it on a document listener, and askReload on each key stroke. This is what is done in the Scala IDE. It is wasteful most of the times, so a better solution would be to do askReload before computing completions, but that runs into misterious race conditions. Should investigate further.

Have a resident compiler for speed-up compilation of instrumented sources

Creating a new compiler instance every time a worksheet is evaluated is time consuming. A resident compiler should speed-up quite a bit the evaluation loop.

Constants are not evaluated

A compiler warning is reported in the editor and no output is produced on evaluation.

object Main {
  1
}

Stop the running evaluation when the user starts typing

Any running evaluation should be stopped as soon as the user starts typing.

Have a preference for turning off evaluation on save

Let's give users a chance to be in control of their worksheet.

Full Indentation support

Mute warning "a pure expression does nothing in statement position"

Given the following worksheet

object Main {
  2
}

The presentation compiler reports the warning a pure expression does nothing in statement position; you may be omitting necessary parentheses. It should be filtered out.

Add a local hyperlink detector

The Scala IDE hyperlink detector assumes a JDT compilation unit, so it won't find targets of hyperlinks in the same file.

We need to add another hyperlink detector that uses only symbol.pos to find the declaration.

After evaluation the caret should be still at the same line

After evaluation, it would be nice if the caret could be placed on the last line, so that the user could just keep typing.

Force reconciliation when the editor is open

Right now, the reconciler does not run before the first change is made. This can be fixed by calling forceReconciling when the editor is open.

The JavaReconciler registers a part listener and calls forceReconciling when the editor is open or activated.

Use Platform JVM launchers to evaluate

Currently we run java, but a proper evaluation engine should use launchers to:

• use the per project/workspace configured JRE
• allow cancellation
• eventually allow debugging

Smart indentation for lines containing evaluation result

Pressing ENTER on a line that has an evaluation result on its left should be intelligently handled, i.e., the caret should move to the next line, but without bringing the evaluation result to the line. (Re #33)

Expose content formatter

It's hooked in the SourceViewerConfiguration, but for some reason there's no menu or action exposed.

Highlight changes in the evaluated results

It would be great to highlight what changed in the evaluated results since last time (if there's an easy way to match lines between runs).

Setup nightly builds

Smart padding when pasting code

Right, when pasting multiline code, the padding between the code and the evaluation result is adjusted. But it is not done when pasting a simple string without new line.

From

prinln("hello")        //> hello

Pasting world result in

println("hello world")        //> hello

It should become

println("hello world")  //> hello

Comment selected line action

It would be nice if we could have the following shortcuts for commenting/uncommenting selected lines in the worksheet

ctrl + / to comment  
ctrl + \ to uncomment

Hook reconciler

Enable the reconciler to show error as you type in the Script editor.

Hyperlinking not working sometimes

Every now and then, hyperlinking fails inside the presentation compiler, inside getLinkPos. This needs to be debugged. It fails consistently, and I noticed that it's the overloading 'resolution' that fails. The code looks like this:

      parseAndEnter(unit)
      val pre = adaptToNewRunMap(ThisType(sym.owner))
      val newsym = pre.typeSymbol.info.decl(sym.name) filter { alt =>
        sym.isType || {
          try {
            val tp1 = pre.memberType(alt) onTypeError NoType
            val tp2 = adaptToNewRunMap(sym.tpe) substSym (originalTypeParams, sym.owner.typeParams)
            matchesType(tp1, tp2, false)
          }
          catch {
          ...

It finds the symbol, and it get's into val tp1 = .., and there it fails. I am trying to hyperlink to List.max which is inside IterableLike, which has a type parameter. Editing a bit the file brings it back to normal, but when it is in a bad mood, it's consistently failing until editing.

Document should be automatically saved after evaluation

The document should be automatically saved after it is updated with the evaluation result.

Add hyperlinking

Allow hyperlinking in the editor. Hook with the sdt.core engine.

Hook the PR Validator

This will be even more needed once we support both Scala 2.9 and 2.10 (Re #40)

Add `Evaluate` action in the context menu

Rebuild up to a line

Hook the support already existing for evaluating up to a given line in the source file.

Wrong source instrumentation generation

For the following worksheet source

object M {}

generates the followin (wrong) instrumented code

import scala.runtime.WorksheetSupport._; def main(args: Array[String])=$execute{}object M {
}

This bug is extremely annoying if you run the evaluation on save, as a build error will be reported right after a worksheet is created (Re #3 and #6)

Worksheet plugin doesn't have a name

After installing it, the worksheet appears in the list of installed plugins, but it has no name.

Add debugger support

Allow to evaluate single expression

Would be nice to allow to evaluate one single expression instead of the whole source file. Even more, we could run the evaluation automatically, that would be very nice indeed. I wonder if this sort of behavior could be implemented via the scala.tools.reflect.ToolBox class.

Add a 'New Worksheet' command.

Make it easy to create new worksheet/script files. Add a 'new worksheet' menu item/toolbar button.

Graceful failure on forward references

The following won't compile

def foo = bar
val bar = 1

The reason is that the whole code is put in a block, where forward references to vals are not allowed. So this is not a bug but something expected.

When this happens, we should fail gracefully and provide the user with some more meaningful information than "error during evaluation".

Implement code folding

Implement collapsing of

• classes
• methods
• comments
• imports

Move evaluation to an external JVM

The evaluator should use the Scala Launcher, so it can be eventually hooked in the debugger.

Evaluation result should be displayed incrementally

It is very important that we get visual feedback of what happens during worksheet evaluation. Right now it's frustrating that nothing happens for a while and then in one instant the screen changes.

Disable `evalutate script` if there are errors

Whenever the worksheet has errors, don't allow the user to try to evaluate it.

Lock editor during evaluation

While the evaluation engine is working, the user may edit the file. Hoever, when evaluation is back, we'll replace the editor contents with the results.

Lock the editor while evaluating!

Remove the `Evaluate script` button

This is a ticket that follows-up on the comment in https://github.com/dragos/scala-worksheet/issues/13#issuecomment-7779135

Allow to customize the evaluation delimiter's color (i.e., `>` and `|`)

• Add the needed infrastructure in the tokenizer
• add a new settingin the Scala Worksheet preference page

Show current error message in the status line

When the cursor is over a presentation compiler error, show the message in the status line.

Unify classpath handling

Compiling and running the worksheet should use the same classpath.

• compiling may use the build manager (has to be investigated if feasible -- don't want to keep analysis artifacts from the worksheet into the project build)
• the classloader used for running should be configured with the same classpath as the compilation classpath

Delay evaluation until project build is finished

Evaluating the worksheet may requires the classes of the current project, so it should not be run when a build is in progress.

Add content assist

Hook the Scala completion proposal into the Script editor.

Add Evaluate Sheet command

Add a command that evaluates the current contents of a Script file and replaces it with the output of the evaluation. Currently, that's the same source augmented with comments that give the result for each expression.

Different background for eval results