Directly import namespaces for improved esbuild output

I should report this upstream, if I can manage to minimize this.

Author: jakebailey

.eslintignore

@@ -1,5 +1,5 @@
 **/node_modules/**
-/built/local/**
+/built/**
 /tests/**
 /lib/**
 /src/lib/*.generated.d.ts

src/.eslintrc.json

@@ -6,7 +6,21 @@
     },
     "rules": {
         "@typescript-eslint/no-unnecessary-qualifier": "error",
-        "@typescript-eslint/no-unnecessary-type-assertion": "error"
+        "@typescript-eslint/no-unnecessary-type-assertion": "error",
+        "no-restricted-globals": ["error",
+            { "name": "setTimeout" },
+            { "name": "clearTimeout" },
+            { "name": "setInterval" },
+            { "name": "clearInterval" },
+            { "name": "setImmediate" },
+            { "name": "clearImmediate" },
+            { "name": "performance" },
+            { "name": "Iterator" },
+            { "name": "Map" },
+            { "name": "ReadonlyMap" },
+            { "name": "Set" },
+            { "name": "ReadonlySet" }
+        ]
     },
     "overrides": [
         {
@@ -20,14 +34,21 @@
                 "local/no-keywords": "off",
 
                 // eslint
-                "no-var": "off"
+                "no-var": "off",
+                "no-restricted-globals": "off"
             }
         },
         {
             "files": ["lib/es2019.array.d.ts"],
             "rules": {
                 "@typescript-eslint/array-type": "off"
             }
+        },
+        {
+            "files": ["debug/**", "harness/**", "testRunner/**"],
+            "rules": {
+                "no-restricted-globals": "off"
+            }
         }
     ]
 }

src/compiler/binder.ts

@@ -1,4 +1,3 @@
-import * as ts from "./_namespaces/ts";
 import {
     __String, AccessExpression, addRelatedInfo, append, appendIfUnique, ArrayBindingElement, ArrayLiteralExpression,
     ArrowFunction, AssignmentDeclarationKind, BinaryExpression, BinaryOperatorToken, BindableAccessExpression,
@@ -59,6 +58,7 @@ import {
     TypeLiteralNode, TypeOfExpression, TypeParameterDeclaration, unescapeLeadingUnderscores, unreachableCodeIsError,
     unusedLabelIsError, VariableDeclaration, WhileStatement, WithStatement,
 } from "./_namespaces/ts";
+import * as performance from "./_namespaces/ts.performance";
 
 /** @internal */
 export const enum ModuleInstanceState {
@@ -236,12 +236,12 @@ const binder = createBinder();
 
 /** @internal */
 export function bindSourceFile(file: SourceFile, options: CompilerOptions) {
-    ts.performance.mark("beforeBind");
+    performance.mark("beforeBind");
     perfLogger.logStartBindFile("" + file.fileName);
     binder(file, options);
     perfLogger.logStopBindFile();
-    ts.performance.mark("afterBind");
-    ts.performance.measure("Bind", "beforeBind", "afterBind");
+    performance.mark("afterBind");
+    performance.measure("Bind", "beforeBind", "afterBind");
 }
 
 function createBinder(): (file: SourceFile, options: CompilerOptions) => void {

src/compiler/checker.ts

@@ -155,7 +155,7 @@ import {
     mangleScopedPackageName, map, Map, mapDefined, MappedSymbol, MappedType, MappedTypeNode, MatchingKeys, maybeBind,
     MemberName, MemberOverrideStatus, memoize, MetaProperty, MethodDeclaration, MethodSignature, minAndMax, MinusToken,
     Modifier, ModifierFlags, modifiersToFlags, modifierToFlag, ModuleBlock, ModuleDeclaration, ModuleInstanceState,
-    ModuleKind, ModuleResolutionKind, moduleSpecifiers, NamedDeclaration, NamedExports, NamedImportsOrExports,
+    ModuleKind, ModuleResolutionKind, NamedDeclaration, NamedExports, NamedImportsOrExports,
     NamedTupleMember, NamespaceDeclaration, NamespaceExport, NamespaceExportDeclaration, NamespaceImport,
     needsScopeMarker, NewExpression, Node, NodeArray, NodeBuilderFlags, nodeCanBeDecorated, NodeCheckFlags, NodeFlags,
     nodeHasName, nodeIsDecorated, nodeIsMissing, nodeIsPresent, nodeIsSynthesized, NodeLinks,
@@ -197,6 +197,8 @@ import {
     walkUpBindingElementsAndPatterns, walkUpParenthesizedExpressions, walkUpParenthesizedTypes,
     walkUpParenthesizedTypesAndGetParentAndChild, WhileStatement, WideningContext, WithStatement, YieldExpression,
 } from "./_namespaces/ts";
+import * as performance from "./_namespaces/ts.performance";
+import * as moduleSpecifiers from "./_namespaces/ts.moduleSpecifiers";
 
 const ambientModuleSymbolRegex = /^".+"$/;
 const anon = "(anonymous)" as __String & string;
@@ -42595,10 +42597,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
     function checkSourceFile(node: SourceFile) {
         tracing?.push(tracing.Phase.Check, "checkSourceFile", { path: node.path }, /*separateBeginAndEnd*/ true);
-        ts.performance.mark("beforeCheck");
+        performance.mark("beforeCheck");
         checkSourceFileWorker(node);
-        ts.performance.mark("afterCheck");
-        ts.performance.measure("Check", "beforeCheck", "afterCheck");
+        performance.mark("afterCheck");
+        performance.measure("Check", "beforeCheck", "afterCheck");
         tracing?.pop();
     }
 

src/compiler/emitter.ts

@@ -78,6 +78,7 @@ import {
     VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement,
     writeCommentRange, writeFile, WriteFileCallbackData, YieldExpression,
 } from "./_namespaces/ts";
+import * as performance from "./_namespaces/ts.performance";
 
 const brackets = createBracketsMap();
 
@@ -366,7 +367,7 @@ export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFi
     const emitterDiagnostics = createDiagnosticCollection();
     const newLine = getNewLineCharacter(compilerOptions, () => host.getNewLine());
     const writer = createTextWriter(newLine);
-    const { enter, exit } = ts.performance.createTimer("printTime", "beforePrint", "afterPrint");
+    const { enter, exit } = performance.createTimer("printTime", "beforePrint", "afterPrint");
     let bundleBuildInfo: BundleBuildInfo | undefined;
     let emitSkipped = false;
 
@@ -1026,7 +1027,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri
     let commentsDisabled = !!printerOptions.removeComments;
     let lastSubstitution: Node | undefined;
     let currentParenthesizerRule: ((node: Node) => Node) | undefined;
-    const { enter: enterComment, exit: exitComment } = ts.performance.createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");
+    const { enter: enterComment, exit: exitComment } = performance.createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");
     const parenthesizer = factory.parenthesizer;
     const typeArgumentParenthesizerRuleSelector: OrdinalParentheizerRuleSelector<Node> = {
         select: index => index === 0 ? parenthesizer.parenthesizeLeadingTypeArgument : undefined

src/compiler/parser.ts

@@ -65,6 +65,7 @@ import {
     UnionOrIntersectionTypeNode, UnionTypeNode, UpdateExpression, VariableDeclaration, VariableDeclarationList,
     VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression,
 } from "./_namespaces/ts";
+import * as performance from "./_namespaces/ts.performance";
 
 const enum SignatureFlags {
     None = 0,
@@ -1005,7 +1006,7 @@ function setExternalModuleIndicator(sourceFile: SourceFile) {
 
 export function createSourceFile(fileName: string, sourceText: string, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, setParentNodes = false, scriptKind?: ScriptKind): SourceFile {
     tracing?.push(tracing.Phase.Parse, "createSourceFile", { path: fileName }, /*separateBeginAndEnd*/ true);
-    ts.performance.mark("beforeParse");
+    performance.mark("beforeParse");
     let result: SourceFile;
 
     perfLogger.logStartParseSourceFile(fileName);
@@ -1026,8 +1027,8 @@ export function createSourceFile(fileName: string, sourceText: string, languageV
     }
     perfLogger.logStopParseSourceFile();
 
-    ts.performance.mark("afterParse");
-    ts.performance.measure("Parse", "beforeParse", "afterParse");
+    performance.mark("afterParse");
+    performance.measure("Parse", "beforeParse", "afterParse");
     tracing?.pop();
     return result;
 }

src/compiler/program.ts

@@ -59,6 +59,7 @@ import {
     VariableStatement, walkUpParenthesizedExpressions, WriteFileCallback, WriteFileCallbackData,
     writeFileEnsuringDirectories, zipToModeAwareCache,
 } from "./_namespaces/ts";
+import * as performance from "./_namespaces/ts.performance";
 
 export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName = "tsconfig.json"): string | undefined {
     return forEachAncestorDirectory(searchPath, ancestor => {
@@ -130,10 +131,10 @@ export function createCompilerHostWorker(options: CompilerOptions, setParentNode
     function getSourceFile(fileName: string, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void): SourceFile | undefined {
         let text: string | undefined;
         try {
-            ts.performance.mark("beforeIORead");
+            performance.mark("beforeIORead");
             text = compilerHost.readFile(fileName);
-            ts.performance.mark("afterIORead");
-            ts.performance.measure("I/O Read", "beforeIORead", "afterIORead");
+            performance.mark("afterIORead");
+            performance.measure("I/O Read", "beforeIORead", "afterIORead");
         }
         catch (e) {
             if (onError) {
@@ -157,7 +158,7 @@ export function createCompilerHostWorker(options: CompilerOptions, setParentNode
 
     function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {
         try {
-            ts.performance.mark("beforeIOWrite");
+            performance.mark("beforeIOWrite");
 
             // NOTE: If patchWriteFileEnsuringDirectory has been called,
             // the system.writeFile will do its own directory creation and
@@ -170,8 +171,8 @@ export function createCompilerHostWorker(options: CompilerOptions, setParentNode
                 path => (compilerHost.createDirectory || system.createDirectory)(path),
                 path => directoryExists(path));
 
-            ts.performance.mark("afterIOWrite");
-            ts.performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");
+            performance.mark("afterIOWrite");
+            performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");
         }
         catch (e) {
             if (onError) {
@@ -1118,7 +1119,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
     const sourceFilesFoundSearchingNodeModules = new Map<string, boolean>();
 
     tracing?.push(tracing.Phase.Program, "createProgram", { configFilePath: options.configFilePath, rootDir: options.rootDir }, /*separateBeginAndEnd*/ true);
-    ts.performance.mark("beforeProgram");
+    performance.mark("beforeProgram");
 
     const host = createProgramOptions.host || createCompilerHost(options);
     const configParsingHost = parseConfigHostFromCompilerHostLike(host);
@@ -1424,8 +1425,8 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
     });
 
     verifyCompilerOptions();
-    ts.performance.mark("afterProgram");
-    ts.performance.measure("Program", "beforeProgram", "afterProgram");
+    performance.mark("afterProgram");
+    performance.measure("Program", "beforeProgram", "afterProgram");
     tracing?.pop();
 
     return program;
@@ -1465,10 +1466,10 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
         const redirectedReference = getRedirectReferenceForResolution(containingFile);
         tracing?.push(tracing.Phase.Program, "resolveModuleNamesWorker", { containingFileName });
-        ts.performance.mark("beforeResolveModule");
+        performance.mark("beforeResolveModule");
         const result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, reusedNames, redirectedReference);
-        ts.performance.mark("afterResolveModule");
-        ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
+        performance.mark("afterResolveModule");
+        performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
         tracing?.pop();
         pullDiagnosticsFromCache(moduleNames, containingFile);
         return result;
@@ -1480,10 +1481,10 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         const redirectedReference = !isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined;
         const containingFileMode = !isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
         tracing?.push(tracing.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName });
-        ts.performance.mark("beforeResolveTypeReference");
+        performance.mark("beforeResolveTypeReference");
         const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode);
-        ts.performance.mark("afterResolveTypeReference");
-        ts.performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
+        performance.mark("afterResolveTypeReference");
+        performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
         tracing?.pop();
         return result;
     }
@@ -2028,7 +2029,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
     function emitBuildInfo(writeFileCallback?: WriteFileCallback): EmitResult {
         Debug.assert(!outFile(options));
         tracing?.push(tracing.Phase.Emit, "emitBuildInfo", {}, /*separateBeginAndEnd*/ true);
-        ts.performance.mark("beforeEmit");
+        performance.mark("beforeEmit");
         const emitResult = emitFiles(
             notImplementedResolver,
             getEmitHost(writeFileCallback),
@@ -2038,8 +2039,8 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             /*onlyBuildInfo*/ true
         );
 
-        ts.performance.mark("afterEmit");
-        ts.performance.measure("Emit", "beforeEmit", "afterEmit");
+        performance.mark("afterEmit");
+        performance.measure("Emit", "beforeEmit", "afterEmit");
         tracing?.pop();
         return emitResult;
     }
@@ -2123,7 +2124,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         // checked is to not pass the file to getEmitResolver.
         const emitResolver = getTypeChecker().getEmitResolver(outFile(options) ? undefined : sourceFile, cancellationToken);
 
-        ts.performance.mark("beforeEmit");
+        performance.mark("beforeEmit");
 
         const emitResult = emitFiles(
             emitResolver,
@@ -2135,8 +2136,8 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             forceDtsEmit
         );
 
-        ts.performance.mark("afterEmit");
-        ts.performance.measure("Emit", "beforeEmit", "afterEmit");
+        performance.mark("afterEmit");
+        performance.measure("Emit", "beforeEmit", "afterEmit");
         return emitResult;
     }
 

src/compiler/sourcemap.ts

@@ -1,11 +1,11 @@
-import * as ts from "./_namespaces/ts";
 import {
     arrayFrom, binarySearchKey, CharacterCodes, combinePaths, compareValues, Debug, DocumentPosition,
     DocumentPositionMapper, DocumentPositionMapperHost, EmitHost, emptyArray, ESMap, every, getDirectoryPath,
     getNormalizedAbsolutePath, getPositionOfLineAndCharacter, getRelativePathToDirectoryOrUrl, identity, isArray,
     isString, Iterator, LineAndCharacter, Map, RawSourceMap, some, sortAndDeduplicate, SortedReadonlyArray,
     SourceMapGenerator, trimStringEnd,
 } from "./_namespaces/ts";
+import * as performance from "./_namespaces/ts.performance";
 
 /** @internal */
 export interface SourceMapGeneratorOptions {
@@ -15,8 +15,8 @@ export interface SourceMapGeneratorOptions {
 /** @internal */
 export function createSourceMapGenerator(host: EmitHost, file: string, sourceRoot: string, sourcesDirectoryPath: string, generatorOptions: SourceMapGeneratorOptions): SourceMapGenerator {
     const { enter, exit } = generatorOptions.extendedDiagnostics
-        ? ts.performance.createTimer("Source Map", "beforeSourcemap", "afterSourcemap")
-        : ts.performance.nullTimer;
+        ? performance.createTimer("Source Map", "beforeSourcemap", "afterSourcemap")
+        : performance.nullTimer;
 
     // Current source map file and its index in the sources list
     const rawSources: string[] = [];

src/compiler/tracing.ts

@@ -1,9 +1,9 @@
-import * as ts from "./_namespaces/ts";
 import {
     combinePaths, ConditionalType, Debug, EvolvingArrayType, getLineAndCharacterOfPosition, getSourceFileOfNode,
     IndexedAccessType, IndexType, IntersectionType, LineAndCharacter, Map, Node, ObjectFlags, Path, ReverseMappedType,
     SubstitutionType, timestamp, Type, TypeFlags, TypeReference, unescapeLeadingUnderscores, UnionType,
 } from "./_namespaces/ts";
+import * as performance from "./_namespaces/ts.performance";
 
 /* Tracing events for the compiler. */
 
@@ -172,13 +172,13 @@ export namespace tracingEnabled {
         // In server mode, there's no easy way to dump type information, so we drop events that would require it.
         if (mode === "server" && phase === Phase.CheckTypes) return;
 
-        ts.performance.mark("beginTracing");
+        performance.mark("beginTracing");
         fs.writeSync(traceFd, `,\n{"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time},"name":"${name}"`);
         if (extras) fs.writeSync(traceFd, `,${extras}`);
         if (args) fs.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
         fs.writeSync(traceFd, `}`);
-        ts.performance.mark("endTracing");
-        ts.performance.measure("Tracing", "beginTracing", "endTracing");
+        performance.mark("endTracing");
+        performance.measure("Tracing", "beginTracing", "endTracing");
     }
 
     function getLocation(node: Node | undefined) {
@@ -200,7 +200,7 @@ export namespace tracingEnabled {
     }
 
     function dumpTypes(types: readonly Type[]) {
-        ts.performance.mark("beginDumpTypes");
+        performance.mark("beginDumpTypes");
 
         const typesPath = legend[legend.length - 1].typesPath!;
         const typesFd = fs.openSync(typesPath, "w");
@@ -329,8 +329,8 @@ export namespace tracingEnabled {
 
         fs.closeSync(typesFd);
 
-        ts.performance.mark("endDumpTypes");
-        ts.performance.measure("Dump types", "beginDumpTypes", "endDumpTypes");
+        performance.mark("endDumpTypes");
+        performance.measure("Dump types", "beginDumpTypes", "endDumpTypes");
     }
 
     export function dumpLegend() {