Major rework of codebase

- Get rid of 'core' and move CLI to cmd/gas directory
- Migrate (most) tests to use Ginkgo and testutils framework
- GAS now expects package to reside in $GOPATH
- GAS now can resolve dependencies for better type checking (if package
  on GOPATH)
- Simplified public API

helpers.go

@@ -19,34 +19,9 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
-	"reflect"
-	"regexp"
 	"strconv"
-	"strings"
 )
 
-// helpfull "canned" matching routines ----------------------------------------
-
-func selectName(n ast.Node, s reflect.Type) (string, bool) {
-	t := reflect.TypeOf(&ast.SelectorExpr{})
-	if node, ok := SimpleSelect(n, s, t).(*ast.SelectorExpr); ok {
-		t = reflect.TypeOf(&ast.Ident{})
-		if ident, ok := SimpleSelect(node.X, t).(*ast.Ident); ok {
-			return strings.Join([]string{ident.Name, node.Sel.Name}, "."), ok
-		}
-	}
-	return "", false
-}
-
-// MatchCall will match an ast.CallNode if its method name obays the given regex.
-func MatchCall(n ast.Node, r *regexp.Regexp) *ast.CallExpr {
-	t := reflect.TypeOf(&ast.CallExpr{})
-	if name, ok := selectName(n, t); ok && r.MatchString(name) {
-		return n.(*ast.CallExpr)
-	}
-	return nil
-}
-
 // MatchCallByPackage ensures that the specified package is imported,
 // adjusts the name for any aliases and ignores cases that are
 // initialization only imports.
@@ -100,11 +75,13 @@ func MatchCallByType(n ast.Node, ctx *Context, requiredType string, calls ...str
 	return nil, false
 }
 
-// MatchCompLit will match an ast.CompositeLit if its string value obays the given regex.
-func MatchCompLit(n ast.Node, r *regexp.Regexp) *ast.CompositeLit {
-	t := reflect.TypeOf(&ast.CompositeLit{})
-	if name, ok := selectName(n, t); ok && r.MatchString(name) {
-		return n.(*ast.CompositeLit)
+// MatchCompLit will match an ast.CompositeLit based on the supplied type
+func MatchCompLit(n ast.Node, ctx *Context, required string) *ast.CompositeLit {
+	if complit, ok := n.(*ast.CompositeLit); ok {
+		typeOf := ctx.Info.TypeOf(complit)
+		if typeOf.String() == required {
+			return complit
+		}
 	}
 	return nil
 }
@@ -117,7 +94,7 @@ func GetInt(n ast.Node) (int64, error) {
 	return 0, fmt.Errorf("Unexpected AST node type: %T", n)
 }
 
-// GetInt will read and return a float value from an ast.BasicLit
+// GetFloat will read and return a float value from an ast.BasicLit
 func GetFloat(n ast.Node) (float64, error) {
 	if node, ok := n.(*ast.BasicLit); ok && node.Kind == token.FLOAT {
 		return strconv.ParseFloat(node.Value, 64)
@@ -125,7 +102,7 @@ func GetFloat(n ast.Node) (float64, error) {
 	return 0.0, fmt.Errorf("Unexpected AST node type: %T", n)
 }
 
-// GetInt will read and return a char value from an ast.BasicLit
+// GetChar will read and return a char value from an ast.BasicLit
 func GetChar(n ast.Node) (byte, error) {
 	if node, ok := n.(*ast.BasicLit); ok && node.Kind == token.CHAR {
 		return node.Value[0], nil
@@ -133,7 +110,7 @@ func GetChar(n ast.Node) (byte, error) {
 	return 0, fmt.Errorf("Unexpected AST node type: %T", n)
 }
 
-// GetInt will read and return a string value from an ast.BasicLit
+// GetString will read and return a string value from an ast.BasicLit
 func GetString(n ast.Node) (string, error) {
 	if node, ok := n.(*ast.BasicLit); ok && node.Kind == token.STRING {
 		return strconv.Unquote(node.Value)
@@ -170,12 +147,10 @@ func GetCallInfo(n ast.Node, ctx *Context) (string, string, error) {
 					t := ctx.Info.TypeOf(expr)
 					if t != nil {
 						return t.String(), fn.Sel.Name, nil
-					} else {
-						return "undefined", fn.Sel.Name, fmt.Errorf("missing type info")
 					}
-				} else {
-					return expr.Name, fn.Sel.Name, nil
+					return "undefined", fn.Sel.Name, fmt.Errorf("missing type info")
 				}
+				return expr.Name, fn.Sel.Name, nil
 			}
 		case *ast.Ident:
 			return ctx.Pkg.Name(), fn.Name, nil
@@ -205,7 +180,7 @@ func GetImportedName(path string, ctx *Context) (string, bool) {
 // GetImportPath resolves the full import path of an identifer based on
 // the imports in the current context.
 func GetImportPath(name string, ctx *Context) (string, bool) {
-	for path, _ := range ctx.Imports.Imported {
+	for path := range ctx.Imports.Imported {
 		if imported, ok := GetImportedName(path, ctx); ok && imported == name {
 			return path, true
 		}