Does TypeScript-Go Support Complex Go Types Like Channels or Functions?

TypeScript-Go does not support Go-specific types such as channels (chan) because it is a TypeScript compiler written in Go, not a Go compiler; however, it fully supports TypeScript function types and declarations.

TypeScript-Go (tsgo) is the native Go port of the TypeScript compiler hosted at microsoft/typescript-go. Because the tool parses and type-checks TypeScript source code to emit JavaScript, it recognizes TypeScript syntax exclusively rather than Go language constructs.

Go Channel Types Are Not Supported

TypeScript-Go cannot process Go-specific types like channels. The compiler’s parser and type checker are built exclusively for the TypeScript language specification, meaning Go syntax such as chan T is never recognized.

A comprehensive search for the keyword chan across the microsoft/typescript-go repository yields zero matches. There is no lexical analysis, parsing logic, or type mapping for channel types anywhere in the codebase. If you attempt to pass a .go source file containing channel syntax to the compiler, the parser will fail immediately because it expects TypeScript grammar.

// This Go code will NOT compile in TypeScript-Go
func worker(ch chan int) {
    // Process channel data
}

Running tsgo worker.go results in a parse error because the file extension and content are not recognized as valid TypeScript.

Function Types Are Fully Supported

While Go functions are not supported, TypeScript-Go handles TypeScript function types comprehensively. This includes function declarations, arrow functions, method signatures, and constructor types. The compiler parses these constructs, performs type checking, and emits standard JavaScript.

TypeScript Function Declarations and Arrow Functions

You can write standard TypeScript functions that compile correctly:

// file: example.ts
function add(a: number, b: number): number {
    return a + b;
}

const multiply = (x: number, y: number): number => x * y;

Compiling with tsgo example.ts produces equivalent JavaScript output:

function add(a, b) {
    return a + b;
}

const multiply = (x, y) => x * y;

Runtime Metadata Serialization

When emitting decorator metadata, TypeScript-Go serializes function types to reference the global Function constructor. This behavior is implemented in internal/transformers/tstransforms/typeserializer.go.

At lines 98–100, the type serializer explicitly handles function and constructor types:

case ast.KindFunctionType, ast.KindConstructorType:
    return s.f.NewIdentifier("Function")

This code ensures that when TypeScript function types are encountered during metadata generation, they are mapped to the JavaScript Function global object rather than attempting to emit Go-specific type information.

Key Source Files and Implementation Details

File Path	Relevance
internal/transformers/tstransforms/typeserializer.go	Handles serialization of TypeScript function types to Function identifiers for decorator metadata (lines 98–100).
internal/parser/types.go	Contains TypeScript-specific type parsing logic including union types, intersections, and literal types.
README.md	Defines the project as a "TypeScript native port," confirming the scope excludes Go language features.

Practical Comparison

Feature	TypeScript-Go Support	Mechanism
Go channels (chan)	❌ None	No lexical tokens or parser rules exist for chan keywords.
TypeScript function declarations	✅ Full	Parsed by internal/parser, type-checked, and emitted as JavaScript functions.
Function type annotations	✅ Full	Serialized to Function global constructor in metadata via typeserializer.go.
Arrow functions (=>)	✅ Full	Supported as standard TypeScript syntax with proper type inference.

Summary

• TypeScript-Go is not a Go compiler. It is a TypeScript-to-JavaScript compiler implemented in Go, which means it only understands TypeScript syntax.
• Go channel types (chan) are completely unsupported. The codebase contains no references to channel syntax, and attempting to compile Go files results in parse errors.
• TypeScript function types are fully supported. This includes declarations, expressions, and arrow functions, with runtime metadata correctly serialized to the global Function constructor as implemented in internal/transformers/tstransforms/typeserializer.go.

Frequently Asked Questions

Can TypeScript-Go compile Go source code that uses channels?

No. TypeScript-Go cannot compile any Go source code, including files containing channel types (chan). The compiler only accepts TypeScript (.ts or .tsx) files. Go-specific keywords like chan, goroutine, or select are not part of the TypeScript grammar and will cause immediate parse errors.

How does TypeScript-Go handle function type metadata in decorators?

When generating decorator metadata, TypeScript-Go maps TypeScript function types to the global JavaScript Function constructor. This logic resides in internal/transformers/tstransforms/typeserializer.go at lines 98–100, where the serializer returns s.f.NewIdentifier("Function") for both KindFunctionType and KindConstructorType nodes.

Is TypeScript-Go a transpiler that converts Go code to JavaScript?

No. TypeScript-Go is a port of the TypeScript compiler itself, written in Go. It compiles TypeScript to JavaScript, similar to the original TypeScript compiler (tsc). It does not transpile Go code to JavaScript or interoperate with Go types at the language level.

What error occurs if I try to compile a .go file with tsgo?

The compiler will report a parse error indicating that the file contains unrecognized tokens or syntax. Since the parser in internal/parser expects TypeScript grammar, Go-specific syntax like func declarations or chan types will fail at the lexical analysis stage before type checking begins.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}