add basic tuple support

Author: Emyrk

bindings/bindings.go

@@ -66,6 +66,8 @@ func (b *Bindings) ToTypescriptExpressionNode(ety ExpressionType) (*goja.Object,
 		siObj, err = b.LiteralKeyword(ety)
 	case *ReferenceType:
 		siObj, err = b.Reference(ety)
+	case *TupleType:
+		siObj, err = b.Tuple(ety.Length, ety.Node)
 	case *ArrayType:
 		siObj, err = b.Array(ety.Node)
 	case *UnionType:
@@ -316,6 +318,24 @@ func (b *Bindings) Array(arrType ExpressionType) (*goja.Object, error) {
 	return res.ToObject(b.vm), nil
 }
 
+func (b *Bindings) Tuple(length int, tupleType ExpressionType) (*goja.Object, error) {
+	tuple, err := b.f("homogeneousTupleType")
+	if err != nil {
+		return nil, err
+	}
+
+	siObj, err := b.ToTypescriptExpressionNode(tupleType)
+	if err != nil {
+		return nil, fmt.Errorf("array type: %w", err)
+	}
+
+	res, err := tuple(goja.Undefined(), b.vm.ToValue(length), siObj)
+	if err != nil {
+		return nil, xerrors.Errorf("call arrayType: %w", err)
+	}
+	return res.ToObject(b.vm), nil
+}
+
 func (b *Bindings) Alias(alias *Alias) (*goja.Object, error) {
 	aliasFunc, err := b.f("aliasDecl")
 	if err != nil {

bindings/expressions.go

@@ -70,6 +70,23 @@ func Reference(name Identifier, args ...ExpressionType) *ReferenceType {
 func (*ReferenceType) isNode()           {}
 func (*ReferenceType) isExpressionType() {}
 
+type TupleType struct {
+	// TODO: Technically tuples can be heterogeneous, but golang does not really
+	// support that. So just assume that all elements are the same type.
+	Node   ExpressionType
+	Length int
+}
+
+func (*TupleType) isNode()           {}
+func (*TupleType) isExpressionType() {}
+
+func HomogeneousTuple(length int, node ExpressionType) *TupleType {
+	return &TupleType{
+		Node:   node,
+		Length: length,
+	}
+}
+
 type ArrayType struct {
 	Node ExpressionType
 }

bindings/walk/walk.go

@@ -29,6 +29,8 @@ func Walk(v Visitor, node bindings.Node) {
 		walkList(v, n.Elements)
 	case *bindings.ArrayType:
 		Walk(v, n.Node)
+	case *bindings.TupleType:
+		Walk(v, n.Node)
 	case *bindings.Interface:
 		walkList(v, n.Parameters)
 		walkList(v, n.Heritage)

convert.go

@@ -806,42 +806,49 @@ func (ts *Typescript) typescriptType(ty types.Type) (parsedType, error) {
 			RaisedComments: append(keyType.RaisedComments, valueType.RaisedComments...),
 		}
 		return parsed, nil
-	case *types.Slice, *types.Array:
-		// Slice/Arrays are pretty much the same.
-		type hasElem interface {
-			Elem() types.Type
+	case *types.Array:
+		// Arrays are essentially tuples. Fixed length arrays.
+		underlying, err := ts.typescriptType(ty.Elem())
+		if err != nil {
+			return parsedType{}, xerrors.Errorf("array: %w", err)
 		}
 
-		arr, _ := ty.(hasElem)
+		if ty.Elem().String() == "byte" {
+			// [32]byte and other similar types are just strings when json marshaled.
+			// Is this ok? Should this be an opinion?
+			return simpleParsedType(ptr(bindings.KeywordString)), nil
+		}
+
+		return parsedType{
+			Value:          bindings.HomogeneousTuple(int(ty.Len()), underlying.Value),
+			TypeParameters: underlying.TypeParameters,
+			RaisedComments: underlying.RaisedComments,
+		}, nil
+	case *types.Slice:
+		//// Slice/Arrays are pretty much the same.
+		//type hasElem interface {
+		//	Elem() types.Type
+		//}
+		//
+		//arr, _ := ty.(hasElem)
 		switch {
 		// When type checking here, just use the string. You can cast it
 		// to a types.Basic and get the kind if you want too :shrug:
-		case arr.Elem().String() == "byte":
+		case ty.Elem().String() == "byte":
 			// All byte arrays are strings on the typescript.
 			// Is this ok?
-			return simpleParsedType(bindings.Array(ptr(bindings.KeywordString))), nil
+			return simpleParsedType(ptr(bindings.KeywordString)), nil
 		default:
 			// By default, just do an array of the underlying type.
-			underlying, err := ts.typescriptType(arr.Elem())
+			underlying, err := ts.typescriptType(ty.Elem())
 			if err != nil {
-				return parsedType{}, xerrors.Errorf("array: %w", err)
+				return parsedType{}, xerrors.Errorf("slice: %w", err)
 			}
-			//genValue := ""
-			//
-			//if underlying.GenericValue != "" {
-			//	genValue = "Readonly<Array<" + underlying.GenericValue + ">>"
-			//}
 			return parsedType{
 				Value:          bindings.Array(underlying.Value),
 				TypeParameters: underlying.TypeParameters,
 				RaisedComments: underlying.RaisedComments,
 			}, nil
-			//return TypescriptType{
-			//	ValueType:     "Readonly<Array<" + underlying.ValueType + ">>",
-			//	GenericValue:  genValue,
-			//	AboveTypeLine: underlying.AboveTypeLine,
-			//	GenericTypes:  underlying.GenericTypes,
-			//}, nil
 		}
 	case *types.Named:
 		n := ty

testdata/array/array.go

@@ -0,0 +1,8 @@
+package array
+
+type StaticArray struct {
+	Numbers   [3]int
+	Slice     []int
+	Hash      [32]byte
+	SliceHash []byte
+}

testdata/array/array.ts

@@ -0,0 +1,13 @@
+// Code generated by 'guts'. DO NOT EDIT.
+
+// From array/array.go
+export interface StaticArray {
+    readonly Numbers: [
+        number,
+        number,
+        number
+    ];
+    readonly Slice: readonly number[];
+    readonly Hash: string;
+    readonly SliceHash: string;
+}

testdata/generics/generics.go

@@ -56,3 +56,5 @@ type UnusedGeneric[B any] struct {
 type UseUnused BasicGeneric[UnusedGeneric[int]]
 type UseUnusedWithGen[T any] BasicGeneric[UnusedGeneric[T]]
 type UseUnusedAlias BasicGeneric[UnusedGeneric[UnusedGeneric[int]]]
+
+type AliasGeneric[A any] = BasicGeneric[A]

testdata/generics/generics.ts

@@ -1,5 +1,10 @@
 // Code generated by 'guts'. DO NOT EDIT.
 
+// From codersdk/generics.go
+export interface AliasGeneric<A extends any> {
+    readonly Val: A;
+}
+
 // From codersdk/generics.go
 export interface BasicGeneric<A extends any> {
     readonly Val: A;

typescript-engine/dist/main.js

@@ -107,6 +107,11 @@ export function arrayType(node: ts.TypeNode): ts.ArrayTypeNode {
   return ts.factory.createArrayTypeNode(node);
 }
 
+export function homogeneousTupleType(length: number, node: ts.TypeNode): ts.TupleTypeNode {
+  const nodes = Array.from({ length }, () => node);
+  return ts.factory.createTupleTypeNode(nodes);
+}
+
 export function aliasDecl(
   modifiers: readonly modifierKeys[] | readonly ts.Modifier[] | undefined,
   name: ts.Identifier | string,
@@ -248,6 +253,7 @@ module.exports = {
   toTypescript: toTypescript,
   interfaceDecl: interfaceDecl,
   literalKeyword: literalKeyword,
+  homogeneousTupleType: homogeneousTupleType,
   arrayType: arrayType,
   aliasDecl: aliasDecl,
   typeParameterDeclaration: typeParameterDeclaration,