@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/test/{SymbolPropagation.test.js → SymbolPropagation.test.ts}

@@ -1,4 +1,3 @@
-// @flow strict-local
 import assert from 'assert';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
@@ -15,10 +14,7 @@ import AssetGraph, {
 } from '../src/AssetGraph';
 import {createDependency as _createDependency} from '../src/Dependency';
 import {createAsset as _createAsset} from '../src/assetUtils';
-import {
-  toProjectPath as _toProjectPath,
-  type ProjectPath,
-} from '../src/projectPath';
+import {toProjectPath as _toProjectPath, ProjectPath} from '../src/projectPath';
 import {propagateSymbols} from '../src/SymbolPropagation';
 import dumpGraphToGraphViz from '../src/dumpGraphToGraphViz';
 import {DEFAULT_ENV, DEFAULT_OPTIONS, DEFAULT_TARGETS} from './test-utils';
@@ -30,30 +26,29 @@ import type {
   DependencyNode,
 } from '../src/types';
 
-const stats = {size: 0, time: 0};
+const stats = {size: 0, time: 0} as const;
 
-function createAsset(opts) {
+function createAsset(opts: any) {
   return _createAsset('/', opts);
 }
 
-function createDependency(opts) {
+function createDependency(opts: any) {
   return _createDependency('/', opts);
 }
 
-function toProjectPath(p) {
+function toProjectPath(p: any) {
   return _toProjectPath('/', p);
 }
 
 function fromProjectPathUnix(p: ProjectPath) {
-  // $FlowFixMe
   return '/' + p;
 }
 
-function nullthrowsAssetNode(v: ?AssetGraphNode): AssetNode {
+function nullthrowsAssetNode(v?: AssetGraphNode | null): AssetNode {
   invariant(v?.type === 'asset');
   return v;
 }
-function nullthrowsDependencyNode(v: ?AssetGraphNode): DependencyNode {
+function nullthrowsDependencyNode(v?: AssetGraphNode | null): DependencyNode {
   invariant(v?.type === 'dependency');
   return v;
 }
@@ -62,28 +57,43 @@ function createAssetGraph(
   assets: Array<
     [
       FilePath,
-      /* symbols (or cleared) */ ?Array<
-        [Symbol, {|local: Symbol, loc?: ?SourceLocation, meta?: ?Meta|}],
-      >,
+      /* symbols (or cleared) */ (
+        | Array<
+            [
+              symbol,
+              {
+                local: symbol;
+                loc?: SourceLocation | null | undefined;
+                meta?: Meta | null | undefined;
+              },
+            ]
+          >
+        | null
+        | undefined
+      ),
       /* sideEffects */ boolean,
-    ],
+    ]
   >,
   dependencies: Array<
     [
       /* from */ FilePath,
       /* to */ FilePath,
-      /* symbols (or cleared) */ ?Array<
-        [
-          Symbol,
-          {|
-            local: Symbol,
-            loc?: ?SourceLocation,
-            isWeak: boolean,
-            meta?: ?Meta,
-          |},
-        ],
-      >,
-    ],
+      /* symbols (or cleared) */ (
+        | Array<
+            [
+              symbol,
+              {
+                local: symbol;
+                loc?: SourceLocation | null | undefined;
+                isWeak: boolean;
+                meta?: Meta | null | undefined;
+              },
+            ]
+          >
+        | null
+        | undefined
+      ),
+    ]
   >,
   isLibrary?: boolean,
 ) {
@@ -174,31 +184,33 @@ function createAssetGraph(
 
 function assertUsedSymbols(
   graph: AssetGraph,
-  _expectedAsset: Array<[FilePath, /* usedSymbols */ Array<Symbol>]>,
+  _expectedAsset: Array<[FilePath, /* usedSymbols */ Array<symbol>]>,
   _expectedDependency: Array<
     [
       FilePath,
       FilePath,
-      /* usedSymbols */ Array<[Symbol, ?[FilePath, ?Symbol]] | [Symbol]> | null,
-    ],
+      /* usedSymbols */ Array<
+        | [symbol, [FilePath, symbol | null | undefined] | null | undefined]
+        | [symbol]
+      > | null,
+    ]
   >,
   isLibrary?: boolean,
 ) {
   let expectedAsset = new Map(
-    _expectedAsset.map(([f, symbols]) => [f, symbols]),
+    _expectedAsset.map(([f, symbols]: [any, any]) => [f, symbols]),
   );
   let expectedDependency = new Map(
-    _expectedDependency.map(([from, to, sym]) => [
+    _expectedDependency.map(([from, to, sym]: [any, any, any]) => [
       from + ':' + to,
-      // $FlowFixMe[invalid-tuple-index]
-      sym ? sym.map((v) => [v[0], v[1] ?? [to, v[0]]]) : sym,
+      sym ? sym.map((v: any) => [v[0], v[1] ?? [to, v[0]]]) : sym,
     ]),
   );
 
   if (isLibrary) {
     let entryDep = nullthrows(
       [...graph.nodes.values()].find(
-        (n) => n?.type === 'dependency' && n.value.sourceAssetId == null,
+        (n: any) => n?.type === 'dependency' && n.value.sourceAssetId == null,
       ),
     );
     invariant(entryDep.type === 'dependency');
@@ -209,7 +221,11 @@ function assertUsedSymbols(
     );
   }
 
-  function assertDependencyUsedSymbols(usedSymbolsUp, expectedMap, id) {
+  function assertDependencyUsedSymbols(
+    usedSymbolsUp: any,
+    expectedMap: any,
+    id: any,
+  ) {
     assertSetEqual(
       new Set(usedSymbolsUp.keys()),
       new Set(expectedMap.keys()),
@@ -272,9 +288,9 @@ function assertUsedSymbols(
 }
 
 function assertSetEqual<T>(
-  actual: $ReadOnlySet<T>,
-  expected: $ReadOnlySet<T>,
-  prefix?: string = '',
+  actual: ReadonlySet<T>,
+  expected: ReadonlySet<T>,
+  prefix: string = '',
 ) {
   assert(
     setEqual(actual, expected),
@@ -286,38 +302,65 @@ async function testPropagation(
   assets: Array<
     [
       FilePath,
-      /* symbols (or cleared) */ ?Array<
-        [Symbol, {|local: Symbol, loc?: ?SourceLocation, meta?: ?Meta|}],
-      >,
+      /* symbols (or cleared) */ (
+        | Array<
+            [
+              symbol,
+              {
+                local: symbol;
+                loc?: SourceLocation | null | undefined;
+                meta?: Meta | null | undefined;
+              },
+            ]
+          >
+        | null
+        | undefined
+      ),
       /* sideEffects */ boolean,
-      /* usedSymbols */ Array<Symbol>,
-    ],
+      /* usedSymbols */ Array<symbol>,
+    ]
   >,
   dependencies: Array<
     [
       /* from */ FilePath,
       /* to */ FilePath,
-      /* symbols (or cleared) */ ?Array<
-        [
-          Symbol,
-          {|
-            local: Symbol,
-            loc?: ?SourceLocation,
-            isWeak: boolean,
-            meta?: ?Meta,
-          |},
-        ],
-      >,
-      /* usedSymbols */ Array<
-        [Symbol, ?[FilePath, ?Symbol]] | [Symbol],
-      > | /* excluded */ null,
-    ],
+      /* symbols (or cleared) */ (
+        | Array<
+            [
+              symbol,
+              {
+                local: symbol;
+                loc?: SourceLocation | null | undefined;
+                isWeak: boolean;
+                meta?: Meta | null | undefined;
+              },
+            ]
+          >
+        | null
+        | undefined
+      ),
+      /* usedSymbols */ (
+        | Array<
+            | [symbol, [FilePath, symbol | null | undefined] | null | undefined]
+            | [symbol]
+          >
+        | /* excluded */ null
+      ),
+    ]
   >,
   isLibrary?: boolean,
 ): Promise<AssetGraph> {
   let {graph, changedAssets} = createAssetGraph(
-    assets.map(([f, symbols, sideEffects]) => [f, symbols, sideEffects]),
-    dependencies.map(([from, to, symbols]) => [from, to, symbols]),
+    assets.map(([f, symbols, sideEffects]: [any, any, any]) => [
+      f,
+      symbols,
+      sideEffects,
+    ]),
+    dependencies.map(([from, to, symbols]: [any, any, any]) => [
+      from,
+      to,
+      symbols,
+    ]),
     isLibrary,
   );
   await dumpGraphToGraphViz(graph, 'test_before');
@@ -336,8 +379,15 @@ async function testPropagation(
 
   assertUsedSymbols(
     graph,
-    assets.map(([f, , , usedSymbols]) => [f, usedSymbols]),
-    dependencies.map(([from, to, , usedSymbols]) => [from, to, usedSymbols]),
+    assets.map(([f, , , usedSymbols]: [any, any, any, any]) => [
+      f,
+      usedSymbols,
+    ]),
+    dependencies.map(([from, to, , usedSymbols]: [any, any, any, any]) => [
+      from,
+      to,
+      usedSymbols,
+    ]),
     isLibrary,
   );
 
@@ -358,7 +408,7 @@ function assertPropagationErrors(
   expected: Iterable<[FilePath, Array<Diagnostic>]>,
 ) {
   assert.deepEqual(
-    [...actual].map(([k, v]) => [
+    [...actual].map(([k, v]: [any, any]) => [
       nullthrowsAssetNode(graph.getNode(k)).value.filePath,
       v,
     ]),
@@ -370,17 +420,17 @@ function changeDependency(
   graph: AssetGraph,
   from: FilePath,
   to: FilePath,
-  cb: ($NonMaybeType<Dependency['symbols']>) => void,
+  cb: (arg1: NonNullable<Dependency['symbols']>) => void,
 ): Iterable<[ContentKey, Asset]> {
   let sourceAssetNode = nullthrowsAssetNode(
     [...graph.nodes.values()].find(
-      (n) => n?.type === 'asset' && n.value.filePath === from,
+      (n: any) => n?.type === 'asset' && n.value.filePath === from,
     ),
   );
   sourceAssetNode.usedSymbolsDownDirty = true;
   let depNode = nullthrowsDependencyNode(
     [...graph.nodes.values()].find(
-      (n) =>
+      (n: any) =>
         n?.type === 'dependency' &&
         n.value.sourcePath === from &&
         n.value.specifier === to,
@@ -393,11 +443,11 @@ function changeDependency(
 function changeAsset(
   graph: AssetGraph,
   asset: FilePath,
-  cb: ($NonMaybeType<Asset['symbols']>) => void,
+  cb: (arg1: NonNullable<Asset['symbols']>) => void,
 ): Iterable<[ContentKey, Asset]> {
   let node = nullthrowsAssetNode(
     [...graph.nodes.values()].find(
-      (n) => n?.type === 'asset' && n.value.filePath === asset,
+      (n: any) => n?.type === 'asset' && n.value.filePath === asset,
     ),
   );
   node.usedSymbolsUpDirty = true;
@@ -440,7 +490,7 @@ describe('SymbolPropagation', () => {
     );
 
     let changedAssets = [
-      ...changeDependency(graph, 'index.js', '/lib.js', (symbols) => {
+      ...changeDependency(graph, 'index.js', '/lib.js', (symbols: any) => {
         symbols.set('b', {
           local: 'b',
           isWeak: false,
@@ -480,7 +530,7 @@ describe('SymbolPropagation', () => {
     );
 
     let changedAssets = [
-      ...changeDependency(graph, 'index.js', '/lib.js', (symbols) => {
+      ...changeDependency(graph, 'index.js', '/lib.js', (symbols: any) => {
         symbols.delete('f');
         symbols.set('f2', {
           local: 'f2',
@@ -523,7 +573,7 @@ describe('SymbolPropagation', () => {
     );
 
     let changedAssets = [
-      ...changeAsset(graph, 'lib.js', (symbols) => {
+      ...changeAsset(graph, 'lib.js', (symbols: any) => {
         symbols.delete('f');
         symbols.set('f2', {
           local: 'f2',
@@ -570,7 +620,7 @@ describe('SymbolPropagation', () => {
     );
 
     let changedAssets = [
-      ...changeDependency(graph, 'index.js', '/lib.js', (symbols) => {
+      ...changeDependency(graph, 'index.js', '/lib.js', (symbols: any) => {
         symbols.set('b', {
           local: 'b',
           isWeak: false,