Check out this TypeScript Compiler API Playground example demonstrating LanguageService type checking:

Additionally, there is a node.js script that parses input typescript code and infers the type of any symbol based on its usage. This script utilizes the TypeScript Compiler API by creating a Program and using "program.getTypeChecker().getTypeAtLocation(someNode)"

For a working example, visit: https://github.com/cancerberoSgx/typescript-plugins-of-mine/blob/master/typescript-ast-util/spec/inferTypeSpec.ts

If you are unfamiliar with the Compiler API, consider starting here and exploring these helpful projects:

• https://github.com/RyanCavanaugh/dts-dom

Best of luck!

Solution 1

To achieve this, utilizing the compiler API with an emit transformer is recommended. The emit transformer receives the Abstract Syntax Tree (AST) during the compilation process and has the ability to modify it. Internally, transformers are used by the compiler to convert TypeScript AST into JavaScript AST which is then written to a file.

The approach involves creating a custom transformer that identifies a function named inferType and adds an additional argument containing the TypeScript type name to the function call.

transformation.ts

import * as ts from 'typescript'
// Defining the transformer factory
function transformer(program: ts.Program): ts.TransformerFactory<ts.SourceFile> {
    let typeChecker =  program.getTypeChecker();
    function transformFile(program: ts.Program, context: ts.TransformationContext, file: ts.SourceFile): ts.SourceFile {
        function visit(node: ts.Node, context: ts.TransformationContext): ts.Node {
            // Handling call expressions
            if (ts.isCallExpression(node)) {
                let target = node.expression;
                // Checking for calls to inferType function
                if(ts.isIdentifier(target) && target.escapedText == 'inferType'){
                    // Obtaining argument's type
                    var type = typeChecker.getTypeAtLocation(node.arguments[0]);
                    // Retrieving type name
                    var typeName = typeChecker.typeToString(type)
                    // Updating the call expression by adding an extra parameter
                    return ts.updateCall(node, node.expression, node.typeArguments, [
                        ... node.arguments,
                        ts.createLiteral(typeName)
                    ]);
                }
            }
            return ts.visitEachChild(node, child => visit(child, context), context);
        }
        const transformedFile = ts.visitEachChild(file, child => visit(child, context), context);
        return transformedFile;
    }
    return (context: ts.TransformationContext) => (file: ts.SourceFile) => transformFile(program, context, file);
}
// Compiling a source file
var cmd = ts.parseCommandLine(['test.ts']);
// Creating the program
let program = ts.createProgram(cmd.fileNames, cmd.options);

// Emitting the program with the custom transformer
var result = program.emit(undefined, undefined, undefined, undefined, {
    before: [
        transformer(program)
    ]
} );

test.ts

let bar = [1, 2, 3];
let bar2 = 5;

function foo(a: number[], b: number) {
return a[0] + b;
}
function inferType<T>(arg:T, typeName?: string) {
    return typeName;

}
inferType(bar); // => "number[]"
inferType(bar2); // => "number"
inferType(foo); // "(number[], number) => number"

Resulting test.js File

var bar = [1, 2, 3];
var bar2 = 5;
function foo(a, b) {
    return a[0] + b;
}
function inferType(arg, typeName) {
    return typeName;
}
inferType(bar, "number[]"); // => "number[]"
inferType(bar2, "number"); // => "number"
inferType(foo, "(a: number[], b: number) => number"); // "(number[], number) => number"

Note: This demonstration serves as a proof of concept, further testing is required. Integrating this custom transformation into your build process may pose challenges, requiring the replacement of the original compiler with this customized version for the desired transformation to take effect.

Solution 2

Another alternative involves leveraging the compiler API to introduce a transformation in the source code pre-compilation. This transformation incorporates the type name directly into the source file. Although presenting the type as a string within the source file, including this transformation in the build process ensures automatic updates. Additionally, using the original compiler and tools remains possible without any alterations.

transformation.ts

import * as ts from 'typescript'

function transformFile(program: ts.Program, file: ts.SourceFile): ts.SourceFile {
    let empty = ()=> {};
    // Placeholder transformation context
    let context: ts.TransformationContext = {
        startLexicalEnvironment: empty,
        suspendLexicalEnvironment: empty,
        resumeLexicalEnvironment: empty,
        endLexicalEnvironment: ()=> [],
        getCompilerOptions: ()=> program.getCompilerOptions(),
        hoistFunctionDeclaration: empty,
        hoistVariableDeclaration: empty,
        readEmitHelpers: ()=>undefined,
        requestEmitHelper: empty,
        enableEmitNotification: empty,
        enableSubstitution: empty,
        isEmitNotificationEnabled: ()=> false,
        isSubstitutionEnabled: ()=> false,
        onEmitNode: empty,
        onSubstituteNode: (hint, node)=>node,
    };
    let typeChecker =  program.getTypeChecker();
    function visit(node: ts.Node, context: ts.TransformationContext): ts.Node {
        // Handling call expressions
        if (ts.isCallExpression(node)) {
            let target = node.expression;
            // Looking for calls to inferType function
            if(ts.isIdentifier(target) && target.escapedText == 'inferType'){
                // Accessing argument's type
                var type = typeChecker.getTypeAtLocation(node.arguments[0]);
                // Retrieving the type name
                var typeName = typeChecker.typeToString(type)
                // Modifying the call expression to include an additional parameter
                var argument =  [
                    ... node.arguments
                ]
                argument[1] = ts.createLiteral(typeName);
                return ts.updateCall(node, node.expression, node.typeArguments, argument);
            }
        }
        return ts.visitEachChild(node, child => visit(child, context), context);
    }

    const transformedFile = ts.visitEachChild(file, child => visit(child, context), context);
    return transformedFile;
}

// Compiling a file
var cmd = ts.parseCommandLine(['test.ts']);
// Establishing the program
let host = ts.createCompilerHost(cmd.options);
let program = ts.createProgram(cmd.fileNames, cmd.options, host);
let printer = ts.createPrinter();

let transformed = program.getSourceFiles()
    .map(f=> ({ o: f, n:transformFile(program, f) }))
    .filter(x=> x.n != x.o)
    .map(x=> x.n)
    .forEach(f => {
        host.writeFile(f.fileName, printer.printFile(f), false, msg => console.log(msg), program.getSourceFiles());
    })

test.ts

let bar = [1, 2, 3];
let bar2 = 5;
function foo(a: number[], b: number) {
    return a[0] + b;
}
function inferType<T>(arg: T, typeName?: string) {
    return typeName;
}
let f = { test: "" };
// Running the provided code automatically appends/updates the type name parameter.
inferType(bar, "number[]");
inferType(bar2, "number"); 
inferType(foo, "(a: number[], b: number) => number"); 
inferType(f, "{ test: string; }");

Is there a way to accomplish this using the compiler API?

The compiler API allows you to examine code when it is represented as a string. For example:

const someObj = ts.someApi(`
// Code 
let bar = [1, 2, 3];
let bar2 = 5;

function foo(a: number[], b: number) {
  return a[0] + b;
}
`);
// use someObj to make inferences about the code

If not, are there any other methods to achieve this?

You can utilize typeof, although it has its limitations (source).

Another approach is to load your own code using nodejs __filename (this will only work in Node.js and only if running through ts-node with raw TypeScript): https://nodejs.org/api/globals.html#globals_filename.

Exploring a different approach with decorators.

function getType(target: Object, propertyKey: string): any {
}

class MyClass {
    @getType foo: number;
    @getType elem: HTMLElement;
}

console.info(Reflect.getMetadata("design:type", Object.getPrototypeOf(MyClass), "foo")); // Number constructor
console.info(Reflect.getMetadata("design:type", Object.getPrototypeOf(MyClass), "elem")); // HTMLElement constructor

Keep in mind that to make this work, certain configurations need to be enabled:

"compilerOptions": {
    "target": "ES5",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
}

Additionally, use the reflect-metadata polyfill. For more information on decorators, check out this article (in Russian).