runtime: goroutine stack exceeds 1000000000-byte limit

.github/workflows/go.yml

@@ -0,0 +1,26 @@
+name: gocode
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  Test:
+    strategy:
+      matrix:
+        go-version: [1.16.x, 1.17.x, 1.18.x, 1.19.x]
+        os: [ubuntu-latest, windows-latest, macos-11]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: ${{ matrix.go-version }}
+
+    - name: Build 
+      run: go build -v
+

README.md

@@ -1,6 +1,34 @@
-## An autocompletion daemon for the Go programming language
+LiteIDE Gocode Tools
+=========
+
+### LiteIDE
+
+_LiteIDE is a simple, open source, cross-platform Go IDE._
+
+### Gocode
+_Gocode is a golang code autocomplete support for LiteIDE._
+
+
+- support Go1.11 Go modules.
+- support Go1.18 generics.
+
+```
+go install github.com/visualfc/gocode@latest
+
+Windows/Linux: copy GOPATH/bin gocode to liteide/bin
+MacOS: copy GOPATH/bin gocode to LiteIDE.app/Contents/MacOS
+```
+
+### Website
+* LiteIDE Source code
+<https://github.com/visualfc/liteide>
+* Gocode Source code
+<https://github.com/visualfc/gocode>
 
-**IMPORTANT: consider switching to https://github.com/mdempsky/gocode if you have problems starting with Go version 1.10, due to changes in binary packages architecture (introduction of package cache) I'm not going to adjust gocode for it for quite some time. There is a higher chance that fork under the given link will have some solution to the problem sooner or later.**
+
+***
+
+## An autocompletion daemon for the Go programming language
 
 Gocode is a helper tool which is intended to be integrated with your source code editor, like vim, neovim and emacs. It provides several advanced capabilities, which currently includes:
 

_testing/all.bash

@@ -1,10 +1,12 @@
 #!/usr/bin/env bash
-gocode close
+go build ../.
+./gocode close
 sleep 0.5
 echo "--------------------------------------------------------------------"
 echo "Autocompletion tests..."
 echo "--------------------------------------------------------------------"
 export XDG_CONFIG_HOME="$(mktemp -d)"
 ./run.rb
 sleep 0.5
-gocode close
+./gocode close
+rm ./gocode

_testing/test.0008/out.expected

@@ -1,5 +1,6 @@
-Found 6 candidates:
+Found 7 candidates:
   func Lock()
+  func TryLock() bool
   func Unlock()
   var Mutex sync.Mutex
   var data map[string][]string

_testing/test.0009/out.expected

@@ -1,3 +1,4 @@
-Found 2 candidates:
+Found 3 candidates:
   func Lock()
+  func TryLock() bool
   func Unlock()

_testing/test.0011/out.expected

@@ -1,19 +1,25 @@
-Found 59 candidates:
+Found 70 candidates:
   func Addr() reflect.Value
   func Bool() bool
   func Bytes() []byte
   func Call(in []reflect.Value) []reflect.Value
   func CallSlice(in []reflect.Value) []reflect.Value
   func CanAddr() bool
+  func CanComplex() bool
+  func CanConvert(t reflect.Type) bool
+  func CanFloat() bool
+  func CanInt() bool
   func CanInterface() bool
   func CanSet() bool
+  func CanUint() bool
   func Cap() int
   func Close()
   func Complex() complex128
   func Convert(t reflect.Type) reflect.Value
   func Elem() reflect.Value
   func Field(i int) reflect.Value
   func FieldByIndex(index []int) reflect.Value
+  func FieldByIndexErr(index []int) (reflect.Value, error)
   func FieldByName(name string) reflect.Value
   func FieldByNameFunc(match func(string) bool) reflect.Value
   func Float() float64
@@ -23,10 +29,12 @@ Found 59 candidates:
   func InterfaceData() [2]uintptr
   func IsNil() bool
   func IsValid() bool
+  func IsZero() bool
   func Kind() reflect.Kind
   func Len() int
   func MapIndex(key reflect.Value) reflect.Value
   func MapKeys() []reflect.Value
+  func MapRange() *reflect.MapIter
   func Method(i int) reflect.Value
   func MethodByName(name string) reflect.Value
   func NumField() int
@@ -45,8 +53,10 @@ Found 59 candidates:
   func SetComplex(x complex128)
   func SetFloat(x float64)
   func SetInt(x int64)
+  func SetIterKey(iter *reflect.MapIter)
+  func SetIterValue(iter *reflect.MapIter)
   func SetLen(n int)
-  func SetMapIndex(key reflect.Value, val reflect.Value)
+  func SetMapIndex(key reflect.Value, elem reflect.Value)
   func SetPointer(x unsafe.Pointer)
   func SetString(x string)
   func SetUint(x uint64)
@@ -58,3 +68,4 @@ Found 59 candidates:
   func Type() reflect.Type
   func Uint() uint64
   func UnsafeAddr() uintptr
+  func UnsafePointer() unsafe.Pointer

_testing/test.0020/out.expected

@@ -1,5 +1,6 @@
-Found 4 candidates:
+Found 5 candidates:
   func Lock()
+  func TryLock() bool
   func Unlock()
   var Dummy Dummy
   var Mutex sync.Mutex

_testing/test.0025/out.expected

@@ -1,5 +1,7 @@
-Found 4 candidates:
-  func Alignof(any) uintptr
-  func Offsetof(any) uintptr
-  func Sizeof(any) uintptr
-  type Pointer uintptr
+Found 6 candidates:
+  func Add(ptr Pointer, len IntegerType) Pointer
+  func Alignof(x ArbitraryType) uintptr
+  func Offsetof(x ArbitraryType) uintptr
+  func Sizeof(x ArbitraryType) uintptr
+  func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
+  type Pointer *ArbitraryType

_testing/test.0059/out.expected

@@ -1,2 +1,2 @@
 Found 1 candidates:
-  func NewReader(r io.Reader) io.Reader
+  func NewReader(r myio.Reader) myio.Reader

ast.go

@@ -0,0 +1,222 @@
+/*
+ Copyright 2021 The GoPlus Authors (goplus.org)
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+package main
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+	"log"
+	"reflect"
+	"strconv"
+)
+
+var (
+	underscore = &ast.Ident{Name: "_"}
+)
+
+var (
+	identTrue   = ident("true")
+	identFalse  = ident("false")
+	identNil    = ident("nil")
+	identAppend = ident("append")
+	identLen    = ident("len")
+	identCap    = ident("cap")
+	identNew    = ident("new")
+	identMake   = ident("make")
+	identIota   = ident("iota")
+)
+
+func ident(name string) *ast.Ident {
+	return &ast.Ident{Name: name}
+}
+
+func boolean(v bool) *ast.Ident {
+	if v {
+		return identTrue
+	}
+	return identFalse
+}
+
+func toRecv(pkg *types.Package, recv *types.Var) *ast.FieldList {
+	if recv == nil {
+		return nil
+	}
+	var names []*ast.Ident
+	if name := recv.Name(); name != "" {
+		names = []*ast.Ident{ident(name)}
+	}
+	fld := &ast.Field{Names: names, Type: toType(pkg, recv.Type())}
+	return &ast.FieldList{List: []*ast.Field{fld}}
+}
+
+// -----------------------------------------------------------------------------
+// function type
+
+func toFieldList(pkg *types.Package, t *types.Tuple) []*ast.Field {
+	if t == nil {
+		return nil
+	}
+	n := t.Len()
+	flds := make([]*ast.Field, n)
+	for i := 0; i < n; i++ {
+		item := t.At(i)
+		var names []*ast.Ident
+		if name := item.Name(); name != "" {
+			names = []*ast.Ident{ident(name)}
+		}
+		typ := toType(pkg, item.Type())
+		flds[i] = &ast.Field{Names: names, Type: typ}
+	}
+	return flds
+}
+
+func toFields(pkg *types.Package, t *types.Struct) []*ast.Field {
+	n := t.NumFields()
+	flds := make([]*ast.Field, n)
+	for i := 0; i < n; i++ {
+		item := t.Field(i)
+		var names []*ast.Ident
+		if !item.Embedded() {
+			names = []*ast.Ident{{Name: item.Name()}}
+		}
+		typ := toType(pkg, item.Type())
+		fld := &ast.Field{Names: names, Type: typ}
+		if tag := t.Tag(i); tag != "" {
+			fld.Tag = &ast.BasicLit{Kind: token.STRING, Value: strconv.Quote(tag)}
+		}
+		flds[i] = fld
+	}
+	return flds
+}
+
+func toVariadic(fld *ast.Field) {
+	t, ok := fld.Type.(*ast.ArrayType)
+	if !ok || t.Len != nil {
+		panic("TODO: not a slice type")
+	}
+	fld.Type = &ast.Ellipsis{Elt: t.Elt}
+}
+
+// -----------------------------------------------------------------------------
+
+func toType(pkg *types.Package, typ types.Type) ast.Expr {
+	switch t := typ.(type) {
+	case *types.Basic: // bool, int, etc
+		return toBasicType(pkg, t)
+	case *types.Pointer:
+		return &ast.StarExpr{X: toType(pkg, t.Elem())}
+	case *types.Named:
+		return toNamedType(pkg, t)
+	case *types.Interface:
+		return toInterface(pkg, t)
+	case *types.Slice:
+		return toSliceType(pkg, t)
+	case *types.Array:
+		return toArrayType(pkg, t)
+	case *types.Map:
+		return toMapType(pkg, t)
+	case *types.Struct:
+		return toStructType(pkg, t)
+	case *types.Chan:
+		return toChanType(pkg, t)
+	case *types.Signature:
+		return toFuncType(pkg, t)
+	case *TypeParam:
+		return toTypeParam(pkg, t)
+	}
+	log.Panicln("TODO: toType -", reflect.TypeOf(typ))
+	return nil
+}
+
+func toObjectExpr(pkg *types.Package, v types.Object) ast.Expr {
+	vpkg, name := v.Pkg(), v.Name()
+	if vpkg == nil || vpkg == g_daemon.autocomplete.typesPkg { // at universe or at this package
+		return ident(name)
+	}
+	return &ast.SelectorExpr{
+		X:   ident(vpkg.Name()),
+		Sel: ident(name),
+	}
+}
+
+func toBasicType(pkg *types.Package, t *types.Basic) ast.Expr {
+	if t.Kind() == types.UnsafePointer {
+		return &ast.SelectorExpr{X: ast.NewIdent("unsafe"), Sel: ast.NewIdent("Pointer")}
+	}
+	if (t.Info() & types.IsUntyped) != 0 {
+		//panic("unexpected: untyped type")
+	}
+	return &ast.Ident{Name: t.Name()}
+}
+
+func isUntyped(pkg *types.Package, typ types.Type) bool {
+	switch t := typ.(type) {
+	case *types.Basic:
+		return (t.Info() & types.IsUntyped) != 0
+	}
+	return false
+}
+
+func toChanType(pkg *types.Package, t *types.Chan) ast.Expr {
+	return &ast.ChanType{Value: toType(pkg, t.Elem()), Dir: chanDirs[t.Dir()]}
+}
+
+var (
+	chanDirs = [...]ast.ChanDir{
+		types.SendRecv: ast.SEND | ast.RECV,
+		types.SendOnly: ast.SEND,
+		types.RecvOnly: ast.RECV,
+	}
+)
+
+func toStructType(pkg *types.Package, t *types.Struct) ast.Expr {
+	list := toFields(pkg, t)
+	return &ast.StructType{Fields: &ast.FieldList{List: list}}
+}
+
+func toArrayType(pkg *types.Package, t *types.Array) ast.Expr {
+	var len ast.Expr
+	if n := t.Len(); n < 0 {
+		len = &ast.Ellipsis{}
+	} else {
+		len = &ast.BasicLit{Kind: token.INT, Value: strconv.FormatInt(t.Len(), 10)}
+	}
+	return &ast.ArrayType{Len: len, Elt: toType(pkg, t.Elem())}
+}
+
+func toSliceType(pkg *types.Package, t *types.Slice) ast.Expr {
+	return &ast.ArrayType{Elt: toType(pkg, t.Elem())}
+}
+
+func toMapType(pkg *types.Package, t *types.Map) ast.Expr {
+	return &ast.MapType{Key: toType(pkg, t.Key()), Value: toType(pkg, t.Elem())}
+}
+
+func toInterface(pkg *types.Package, t *types.Interface) ast.Expr {
+	var flds []*ast.Field
+	for i, n := 0, t.NumEmbeddeds(); i < n; i++ {
+		typ := toType(pkg, t.EmbeddedType(i))
+		fld := &ast.Field{Type: typ}
+		flds = append(flds, fld)
+	}
+	for i, n := 0, t.NumExplicitMethods(); i < n; i++ {
+		fn := t.ExplicitMethod(i)
+		name := ident(fn.Name())
+		typ := toFuncType(pkg, fn.Type().(*types.Signature))
+		fld := &ast.Field{Names: []*ast.Ident{name}, Type: typ}
+		flds = append(flds, fld)
+	}
+	return &ast.InterfaceType{Methods: &ast.FieldList{List: flds}}
+}