chore: replace 'string' identifiers with Identifier type

Type includes package and prefix information. Allowing package
collisions to be more gracefully handled.

Author: Emyrk

README.md

@@ -28,6 +28,14 @@ interface SimpleType<T extends Comparable> {
 }
 ```
 
+# How to use it
+
+`guts` is a library, not a command line utility. This is to allow configuration with code, and also helps with package resolution.
+
+See the [simple example](./example/simple) for a basic usage of the library.
+
+```go
+
 # How it works
 
 `guts` first parses a set of golang packages. The Go AST is traversed to find all the types defined in the packages. 

bindings/ast.go

@@ -2,6 +2,7 @@ package bindings
 
 import (
 	"fmt"
+	"go/types"
 
 	"github.com/dop251/goja"
 )
@@ -13,7 +14,20 @@ type isTypescriptNode struct{}
 
 func (isTypescriptNode) isNode() {}
 
-type Identifier string
+type Identifier struct {
+	Name    string
+	Package *types.Package
+	Prefix  string
+}
+
+func (i Identifier) String() string {
+	return i.Name
+}
+
+// Ref returns the identifier reference to be used in the generated code.
+func (i Identifier) Ref() string {
+	return i.Prefix + i.Name
+}
 
 type Source struct {
 	File string

bindings/bindings.go

@@ -128,7 +128,7 @@ func (b *Bindings) Reference(ref *ReferenceType) (*goja.Object, error) {
 	}
 
 	res, err := modifier(goja.Undefined(),
-		b.vm.ToValue(ref.Name),
+		b.vm.ToValue(ref.Name.Ref()),
 		b.vm.NewArray(args...),
 	)
 	if err != nil {
@@ -225,7 +225,7 @@ func (b *Bindings) Interface(ti *Interface) (*goja.Object, error) {
 
 	res, err := interfaceDecl(goja.Undefined(),
 		b.vm.ToValue(ToStrings(ti.Modifiers)),
-		b.vm.ToValue(string(ti.Name)),
+		b.vm.ToValue(ti.Name.Ref()),
 		b.vm.NewArray(typeParams...),
 		b.vm.NewArray(heritage...),
 		b.vm.NewArray(fields...),
@@ -321,7 +321,7 @@ func (b *Bindings) Alias(alias *Alias) (*goja.Object, error) {
 
 	res, err := aliasFunc(goja.Undefined(),
 		b.vm.ToValue(ToStrings(alias.Modifiers)),
-		b.vm.ToValue(string(alias.Name)),
+		b.vm.ToValue(alias.Name.Ref()),
 		b.vm.NewArray(typeParams...),
 		siObj,
 	)
@@ -361,7 +361,7 @@ func (b *Bindings) TypeParameter(ty *TypeParameter) (*goja.Object, error) {
 
 	res, err := typeParamF(goja.Undefined(),
 		b.vm.ToValue(ToStrings(ty.Modifiers)),
-		b.vm.ToValue(ty.Name),
+		b.vm.ToValue(ty.Name.Ref()),
 		paramType,
 		defaultType,
 	)
@@ -580,7 +580,7 @@ func (b *Bindings) VariableDeclaration(decl *VariableDeclaration) (*goja.Object,
 
 	res, err := aliasFunc(
 		goja.Undefined(),
-		b.vm.ToValue(decl.Name),
+		b.vm.ToValue(decl.Name.Ref()),
 		b.vm.ToValue(decl.ExclamationMark),
 		declType,
 		declInit,

bindings/declarations.go

@@ -56,7 +56,7 @@ func (*Alias) isDeclarationType() {}
 // - Type: Comparable
 // - DefaultType: nil
 type TypeParameter struct {
-	Name      string
+	Name      Identifier
 	Modifiers []Modifier
 	Type      ExpressionType
 	// DefaultType does not map to any Golang concepts and will never be
@@ -71,7 +71,7 @@ func Simplify(p []*TypeParameter) ([]*TypeParameter, error) {
 	params := make([]*TypeParameter, 0, len(p))
 	exists := make(map[string]*TypeParameter)
 	for _, tp := range p {
-		if found, ok := exists[tp.Name]; ok {
+		if found, ok := exists[tp.Name.Ref()]; ok {
 			// Compare types, make sure they are the same
 			equal := reflect.DeepEqual(found, tp)
 			if !equal {
@@ -80,7 +80,7 @@ func Simplify(p []*TypeParameter) ([]*TypeParameter, error) {
 			continue
 		}
 		params = append(params, tp)
-		exists[tp.Name] = tp
+		exists[tp.Name.Ref()] = tp
 	}
 	return params, nil
 }

bindings/expressions.go

@@ -51,14 +51,14 @@ func (*LiteralType) isExpressionType() {}
 
 // ReferenceType can be used to reference another type by name
 type ReferenceType struct {
-	Name string `json:"name"`
+	Name Identifier `json:"name"`
 	// TODO: Generics
 	Arguments []ExpressionType `json:"arguments"`
 
 	isTypescriptNode
 }
 
-func Reference(name string, args ...ExpressionType) *ReferenceType {
+func Reference(name Identifier, args ...ExpressionType) *ReferenceType {
 	return &ReferenceType{Name: name, Arguments: args}
 }
 
@@ -122,7 +122,7 @@ type VariableDeclarationList struct {
 func (*VariableDeclarationList) isExpressionType() {}
 
 type VariableDeclaration struct {
-	Name            string
+	Name            Identifier
 	ExclamationMark bool
 	Type            ExpressionType
 	Initializer     ExpressionType

bindings/string.go

@@ -4,7 +4,6 @@ import "fmt"
 
 // These string functions are purely for debugging
 
-func (i Identifier) String() string        { return string(i) }
 func (a Alias) String() string             { return fmt.Sprintf("Alias:%s", a.Name) }
 func (k LiteralKeyword) String() string    { return string(k) }
 func (a ArrayType) String() string         { return fmt.Sprintf("[]%s", a.Node) }

builtins.go

@@ -2,21 +2,25 @@ package guts
 
 import "github.com/coder/guts/bindings"
 
-const (
-	builtInComparable = "Comparable"
+var (
+	builtInComparable = bindings.Identifier{Name: "Comparable"}
+	builtInString     = bindings.Identifier{Name: "string"}
+	builtInNumber     = bindings.Identifier{Name: "number"}
+	builtInBoolean    = bindings.Identifier{Name: "boolean"}
+	builtInRecord     = bindings.Identifier{Name: "Record"}
 )
 
 func (ts *Typescript) includeComparable() {
 	// The zzz just pushes it to the end of the sorting.
 	// Kinda strange, but it works.
-	_ = ts.setNode(builtInComparable, typescriptNode{
+	_ = ts.setNode(builtInComparable.Ref(), typescriptNode{
 		Node: &bindings.Alias{
 			Name:      builtInComparable,
 			Modifiers: []bindings.Modifier{},
 			Type: bindings.Union(
-				bindings.Reference("string"),
-				bindings.Reference("number"),
-				bindings.Reference("boolean"),
+				bindings.Reference(builtInString),
+				bindings.Reference(builtInNumber),
+				bindings.Reference(builtInBoolean),
 			),
 			Parameters: []*bindings.TypeParameter{},
 			Source:     bindings.Source{},

cmd/gots/main.go

@@ -16,7 +16,7 @@ func main() {
 	}
 
 	for _, arg := range os.Args[1:] {
-		err = gen.Include(arg, true)
+		err = gen.IncludeGenerate(arg)
 		if err != nil {
 			panic(err)
 		}

config/mutations.go

@@ -86,11 +86,12 @@ func EnumLists(ts *guts.Typescript) {
 					Declarations: &bindings.VariableDeclarationList{
 						Declarations: []*bindings.VariableDeclaration{
 							{
-								Name:            name,
+								// TODO: Fix this with Identifier's instead of "string"
+								Name:            bindings.Identifier{Name: name},
 								ExclamationMark: false,
 								Type: &bindings.ArrayType{
 									// The type is the enum type
-									Node: bindings.Reference(key),
+									Node: bindings.Reference(bindings.Identifier{Name: key}),
 								},
 								Initializer: &bindings.ArrayLiteralType{
 									Elements: values,
@@ -112,3 +113,38 @@ func EnumLists(ts *guts.Typescript) {
 		}
 	}
 }
+
+// MissingReferencesToAny will change any references to types that are not found in the
+// typescript tree to 'any'.
+func MissingReferencesToAny(ts *guts.Typescript) {
+	// Find all valid references to types
+	valid := make(map[string]struct{})
+	ts.ForEach(func(key string, node bindings.Node) {
+		switch node.(type) {
+		case *bindings.Alias, *bindings.Interface, *bindings.VariableDeclaration:
+			valid[key] = struct{}{}
+		}
+	})
+
+	ts.ForEach(func(key string, node bindings.Node) {
+		fixMissingReferences(valid, node)
+	})
+}
+
+func fixMissingReferences(valid map[string]struct{}, node bindings.Node) bool {
+	switch node := node.(type) {
+	case *bindings.Interface:
+		for _, field := range node.Fields {
+			if !fixMissingReferences(valid, field.Type) {
+				field.FieldComments = append(field.FieldComments, "Reference not found, changed to 'any'")
+			}
+		}
+	case *bindings.Alias:
+		if _, ok := valid[node.Name.Ref()]; !ok {
+			// Invalid reference, change to 'any'
+			node.Type = ptr(bindings.KeywordAny)
+			return false
+		}
+	}
+	return true
+}