Feature request: provide code completion

[morangorin]

Ideally, there would be a function available on fast.Interp like:
Complete(prefix string) []string
which would return the list of possible completions. It seems that such list could be returned to liner using line.SetCompleter to improve the REPL provided in gomacro.

[cosmos72]

I agree it would be very useful :)

The same feature has bee requested and discussed in gophernotes, a Jupyter kernel for Go that uses gomacro - see gopherdata/gophernotes#22
A quick-and-dirty solution is implementing completion against global names - quite easy to implement, but also quite limited.
A thorough completion is much harder: it needs the whole code surrounding the (in)complete word, in order to also find local variables and - this is the real difficulty - their types.

In alternative, I thought about using https://github.com/nsf/gocode and, while somewhat easier, it's not completely trivial (requires writing interpreted code to files) and introduces a significant dependency.

Suggestions are welcome :)

[morangorin]

What about running the gomacro interpreter and using the reflect package? For instance, if we have:
r := rand.New(rand.NewSource(99))
with the following List function defined:

func List(v interface{}) []string {
	t := reflect.TypeOf(v)
	r := []string{}
	if t.Kind() == reflect.Struct {
		for i := 0; i < t.NumField(); i++ {
			r = append(r, t.Field(i).Name)
		}
	}
	for i := 0; i < t.NumMethod(); i++ {
		r = append(r, t.Method(i).Name)
	}
	return r
}

then evaluating List(r) with the interpreter will return the list of candidates [ExpFloat64 Float32 ... Seed Shuffle Uint32 Uint64] without additional data structures.

I guess there is the special case of package for which this method would not work. But then perhaps global names would be more appropriate for that case and for global variables in general.

[cosmos72]

Yes, looking up fields and methods of an existing variable is relatively straightforward (it's only slightly more complicated than your example code because methods of interpreted types are emulated). And looking up symbols of imported packages is straightforward too.

Maybe that's already enough to be useful...

the missing part would be completion of local variables' fields and methods, as for example:

type S struct { T }
type T int
func (t T) String() string {
  return "T"
}
func foo(s S) {
  println(s.#

Where the input source is not yet complete (parenthesis and braces are not balanced) and the user hit TAB at the # - how can gomacro determine the type of local variable s in order to show its fields and methods?

The only solution I am aware of is to parse the code in a new context (to avoid completion side effects as defining new types, functions, methods...) with an error-resistant parser and type checker - but gomacro currently has neither of them

[morangorin]

Python code completion in ipython or jupyter only provides what you describe as 'straightforward' and it is already super useful. Can the work done for gophernotes/issues/22 be reused for the terminal prompt?

[cosmos72]

You're talking about @jpark-dev comment gopherdata/gophernotes#22 (comment) and his patch, right?
I did not examine it yet - if I have time, I will have a look in the next days

[cosmos72]

Done :)
See commit 4159592

Feedback is welcome :)

[morangorin]

It is brilliant. I am already wondering how I was doing before! Thank you very much.