Memory leakage occurs in the getTypeAtLocation method in the latest version.

[majie77]

Acknowledgement

• I acknowledge that issues using this template may be closed without further explanation at the maintainer's discretion.

Comment

Invoke the getTypeAtLocation method one million times cyclically. Before and after the loop, perform GC and print heapUsed. The memory usage increases by about 150 MB.

[jakebailey]

You haven't provided much information.

Are you calling it on the same location each time, or a different one?

How much memory is being used before/after?

If you're saying it happens in the "latest" version, are you saying that it didn't used to happen?

If it didn't happen before, have you tried to bisect with https://www.npmjs.com/package/every-ts?

[majie77]

My demo code is as follows:

global.gc();
const m = process.memoryUsage();
console.log(m.heapUsed);
for (let a=1;a <= 1000000;a++) {
typeChecker.getTypeAtLocation(node.typeName);
}
global.gc();
const m1 = process.memoryUsage();
console.log(m1.heapUsed);

Test results of different versions：

[RyanCavanaugh]

Please post a sample we can run ourselves; this could depend on any number of factors

[majie77]

A code demo that can run immediately：

const ts = require("typescript");
const testFile = "test.ts";
const code = `
interface Person {
    name: string;
    age: number;
}

function printName(person: Person): void {
    console.log(person.name);
}
`;

const program = ts.createProgram([testFile],{allowJs: false,experimentalDecorators: true, etsAnnotationsEnable: true, strict: true});
const typeChecker = program.getTypeChecker();
const sourceFile = ts.createSourceFile(
    testFile,
    code,
    ts.ScriptTarget.Latest,
    true,
    ts.ScriptKind.TS
);


global.gc();
const m = process.memoryUsage();
console.log(m.heapUsed/1024/1024);

function findTypeReferences(node) {
    if (node.kind === ts.SyntaxKind.TypeReference) {
        for (let a=1;a <= 1000000;a++) {
            typeChecker.getTypeAtLocation(node.typeName);
        }
    }
    ts.forEachChild(node, findTypeReferences);
}

findTypeReferences(sourceFile);

global.gc();
const m1 = process.memoryUsage();
console.log(`after,${m1.heapUsed/1024/1024}`);

[RyanCavanaugh]

Verifying that the number just keeps going up

const ts = require("typescript");
const testFile = "test.ts";
const code = `
interface Person {
    name: string;
    age: number;
}

function printName(person: Person): void {
    console.log(person.name);
}
`;

const program = ts.createProgram([testFile], { allowJs: false, experimentalDecorators: true, etsAnnotationsEnable: true, strict: true });
const typeChecker = program.getTypeChecker();
const sourceFile = ts.createSourceFile(
    testFile,
    code,
    ts.ScriptTarget.Latest,
    true,
    ts.ScriptKind.TS
);

function findTypeReferences(node) {
    if (node.kind === ts.SyntaxKind.TypeReference) {
        for (let a = 1; a <= 1000000; a++) {
            void typeChecker.getTypeAtLocation(node.typeName);
        }
    }
    ts.forEachChild(node, findTypeReferences);
}

for (let x = 1; x <= 1000; x++) {
  global.gc();
  const m2 = process.memoryUsage();
  console.log(`${m2.heapUsed / 1024 / 1024}`);
  findTypeReferences(sourceFile);
}

->

57.838043212890625
190.1006317138672
324.61339569091797
457.8843307495117
579.9553298950195
718.8173522949219
840.8882446289062
988.1521453857422
1110.258056640625

[majie77]

I found that if ignoreErrors of the resolveEntityName() method is set to TRUE, the memory leak will be fixed. What is the function of this parameter? Can I set it to TRUE?

[RyanCavanaugh]

I can't figure out why you would be doing this (calling getTypeAtLocation for the same location more than once) in the first place, so it's hard to advise.

[majie77]

This is only a demo to prove that the getTypeAtLocation may have a memory leak problem. During actual compilation, the method may be invoked in different locations.

[jakebailey]

I took a look at this; all of the memory being added on are coming from addLazyDiagnostic, stemming from getSymbolOfNameOrPropertyAccessExpression calling resolveEntityName with errors enabled. Flipping that breaks no tests and fixes the leak.

Note that this is more or less happening because you're asking questions about a program with errors, so not having errors would also fix this (but I think this is probably valuable to fix just because most programs are in an invalid state in an editor, in ts-eslint especially).