TypeScript compiler with Reflection capabilities

License: Other

Language: TypeScript

Keywords: metadata, reflection, types, typescript


A enhanced (unofficial) version of the TypeScript compiler that provides Reflection capabilities.


Releases follow the official ones, so I try to keep the same scheme. For the latest stable version:

npm install -g reflec-ts

For the latest available version:

npm install -g reflec-ts@next

I try to keep reflec-ts master aligned with the official one, at least weekly.


You can find some examples here.

How it works

Every language that offers real reflection capabilities has to provide two things, both at coding time and runtime:

  • Classes, interfaces, for building type hierarchies
  • Meta-classes for accessing reflection data (for an example in Java, see Class).

Actually, if picked individually, these two features are not enough to achieve reflection, but they should be linked in some way. For example, we generally expect to retrieve class metadata from its identifier (for example String.class in Java), or we want to instantiate a new object from class metadata (Class.newInstance() in Java).

Here, this aspect has been the hardest one to implement, since the mere type serialization was already achieved some time ago by many people (LanguageService API is enough).

In order to link metadata with classes (constructors in JavaScript) reflec-ts injects some synthetic instructions in the AST, just after the parsing phase. These instructions do not contain all type information, but just link the metadata object with constructors. In a second phase, just before the usual JS code emitting, reflec-ts builds a special JS file (Reflection.js) that contains metadata for all types.

Since we modify the AST, types metadata are immediately visible from the IDE (LanguageService uses the same parser), so we can achieve something like the following:

reflec-ts demo

As you can see, the compiler added some features, like getClass() method on the class and MyInterface literal, that contains all interface details.


It works exactly like the official TypeScript compiler. You can use reflec-tsc:

reflec-tsc -p /path/to/project/

or you can reference typescriptServices.js in your IDE.

Now reflection.d.ts, which contains all meta-interfaces, is included in lib.d.ts; if your IDE supports it, you can point to this file which contains Reflection definitions, too. I tested this with the latest release of Atom (using atom-typescript plugin), and it works well.

Note: unfortunately, this version seems not to work with Visual Studio 2015. Currently it includes the 1.8.x branch of the compiler, maybe we have to wait for 2.x compatibility.

How to enable reflection

Open tsconfig.json and add "reflectionEnabled": true, like the following snippet:

    "compilerOptions": {
        "noImplicitAny": true,
        "removeComments": false
    "files": [
    "reflectionEnabled": true

And now show me the code!

In one of your typescript files, create an interface and a class that implements it like the following:

interface MyInterface {
    doSomething(what: string): number;

class MyClass implements MyInterface {
    counter = 0;

    doSomething(what: string): number {
        console.log('Doing ' + what);
        return this.counter++;

now let's print some useful things about MyClass...

let c: Class = MyClass.getClass();

for (let int of c.implements) {
    console.log('Implemented interface: ' + int.name)

for (let member of c.members) {
    console.log("Member name: " + member.name + " - member kind: " + member.type.kind);

compile with reflec-ts, launch it and, voilà!

$ node main.js
Implemented interface: MyInterface
Member name: counter - member kind: number
Member name: doSomething - member kind: function

now let's build an instance of MyClass from its metadata...

let c: Class = MyClass.getClass();
let ctor = c.getConstructor<any>(); //you may use an interface instead of <any> ;)
let myObj = new ctor();
console.log('myObj instanceof MyClass: ' + (myObj instanceof MyClass));
myObj.doSomething('nothing :)');

launch it, and... yeah!!

$ node main.js
myObj instanceof MyClass: true
Doing nothing :)

Current limitations

There are a few limitations, some of them are by design, others may be overcome in the future.

  • reflec-ts needs tsconfig.json, it cannot be enabled with command line parameters.
  • Legacy --outFile is not supported.
  • If you need types metadata from an external library, you must include its .d.ts type definition file. Only referred types will be included in type serialization.


I'm defining the roadmap right now, the project will evolve to support full reflection capabilities and modularity. At the moment, there are some things that have to be completed soon:

  • Support for class expressions. done in v0.3.6
  • Support for Union, Intersection, done in v0.3.7
  • Support for Object Literals
  • Support for Tuples
  • Support for String Literals
  • Sample projects (currently in progress)s


This project is derived from the TypeScript project, but it is not officially supported by Microsoft. See LICENSE for details.

Project Statistics

Sourcerank 5
Repository Size 254 MB
Stars 49
Forks 2
Watchers 9
Open issues 5
Dependencies 52
Contributors 165
Tags 3
Last updated
Last pushed

Top Contributors See all

Andrew Ochsner Mohamed Hegazy Anders Hejlsberg Daniel Rosenwasser Vladimir Matveev CyrusNajmabadi Yui Ron Buckton Sheetal Nandi Nathan Shively-Sanders Jason Freeman Andy Hanson Ryan Cavanaugh Zhengbo Li Wesley Wigham Kagami Sascha Rosylight Paul van Brenk Arthur Ozga jramsay Richard Knoll

Packages Referencing this Repo

TypeScript compiler with Reflection capabilities
Latest release 0.3.9 - Updated - 49 stars

Recent Tags See all

0.3.0 August 19, 2016
0.2.0 August 18, 2016
0.1.0 August 15, 2016

Something wrong with this page? Make a suggestion

Last synced: 2016-09-04 18:17:28 UTC

Login to resync this repository