refactor: disable getSatisfying for some resolvers

packages/plugin-exec/sources/ExecResolver.ts

@@ -39,17 +39,29 @@ export class ExecResolver implements Resolver {
   }
 
   async getCandidates(descriptor: Descriptor, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const locator = await this.getCandidateForDescriptor(descriptor, opts);
+    if (!opts.fetchOptions)
+      throw new Error(`Assertion failed: This resolver cannot be used unless a fetcher is configured`);
+
+    const {path, parentLocator} = execUtils.parseSpec(descriptor.range);
+
+    if (parentLocator === null)
+      throw new Error(`Assertion failed: The descriptor should have been bound`);
 
-    return [locator];
+    const generatorFile = await execUtils.loadGeneratorFile(structUtils.makeRange({
+      protocol: PROTOCOL,
+      source: path,
+      selector: path,
+      params: {
+        locator: structUtils.stringifyLocator(parentLocator),
+      },
+    }), PROTOCOL, opts.fetchOptions);
+    const generatorHash = hashUtils.makeHash(`${CACHE_VERSION}`, generatorFile).slice(0, 6);
+
+    return [execUtils.makeLocator(descriptor, {parentLocator, path, generatorHash, protocol: PROTOCOL})];
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const {reference: execReference} = await this.getCandidateForDescriptor(descriptor, opts);
-
-    return references
-      .filter(reference => reference === execReference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions) {
@@ -79,26 +91,4 @@ export class ExecResolver implements Resolver {
       bin: manifest.bin,
     };
   }
-
-  private async getCandidateForDescriptor(descriptor: Descriptor, opts: ResolveOptions) {
-    if (!opts.fetchOptions)
-      throw new Error(`Assertion failed: This resolver cannot be used unless a fetcher is configured`);
-
-    const {path, parentLocator} = execUtils.parseSpec(descriptor.range);
-
-    if (parentLocator === null)
-      throw new Error(`Assertion failed: The descriptor should have been bound`);
-
-    const generatorFile = await execUtils.loadGeneratorFile(structUtils.makeRange({
-      protocol: PROTOCOL,
-      source: path,
-      selector: path,
-      params: {
-        locator: structUtils.stringifyLocator(parentLocator),
-      },
-    }), PROTOCOL, opts.fetchOptions);
-    const generatorHash = hashUtils.makeHash(`${CACHE_VERSION}`, generatorFile).slice(0, 6);
-
-    return execUtils.makeLocator(descriptor, {parentLocator, path, generatorHash, protocol: PROTOCOL});
-  }
 }

packages/plugin-file/sources/FileResolver.ts

@@ -45,17 +45,35 @@ export class FileResolver implements Resolver {
   }
 
   async getCandidates(descriptor: Descriptor, dependencies: unknown, opts: ResolveOptions) {
-    const locator = await this.getCandidateForDescriptor(descriptor, opts);
+    if (!opts.fetchOptions)
+      throw new Error(`Assertion failed: This resolver cannot be used unless a fetcher is configured`);
+
+    const {path, parentLocator} = fileUtils.parseSpec(descriptor.range);
+
+    if (parentLocator === null)
+      throw new Error(`Assertion failed: The descriptor should have been bound`);
 
-    return [locator];
+    const archiveBuffer = await fileUtils.makeBufferFromLocator(
+      structUtils.makeLocator(descriptor,
+        structUtils.makeRange({
+          protocol: PROTOCOL,
+          source: path,
+          selector: path,
+          params: {
+            locator: structUtils.stringifyLocator(parentLocator),
+          },
+        })
+      ),
+      {protocol: PROTOCOL, fetchOptions: opts.fetchOptions}
+    );
+
+    const folderHash = hashUtils.makeHash(`${CACHE_VERSION}`, archiveBuffer).slice(0, 6);
+
+    return [fileUtils.makeLocator(descriptor, {parentLocator, path, folderHash, protocol: PROTOCOL})];
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const {reference: fileReference} = await this.getCandidateForDescriptor(descriptor, opts);
-
-    return references
-      .filter(reference => reference === fileReference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions) {
@@ -85,32 +103,4 @@ export class FileResolver implements Resolver {
       bin: manifest.bin,
     };
   }
-
-  private async getCandidateForDescriptor(descriptor: Descriptor, opts: ResolveOptions) {
-    if (!opts.fetchOptions)
-      throw new Error(`Assertion failed: This resolver cannot be used unless a fetcher is configured`);
-
-    const {path, parentLocator} = fileUtils.parseSpec(descriptor.range);
-
-    if (parentLocator === null)
-      throw new Error(`Assertion failed: The descriptor should have been bound`);
-
-    const archiveBuffer = await fileUtils.makeBufferFromLocator(
-      structUtils.makeLocator(descriptor,
-        structUtils.makeRange({
-          protocol: PROTOCOL,
-          source: path,
-          selector: path,
-          params: {
-            locator: structUtils.stringifyLocator(parentLocator),
-          },
-        })
-      ),
-      {protocol: PROTOCOL, fetchOptions: opts.fetchOptions}
-    );
-
-    const folderHash = hashUtils.makeHash(`${CACHE_VERSION}`, archiveBuffer).slice(0, 6);
-
-    return fileUtils.makeLocator(descriptor, {parentLocator, path, folderHash, protocol: PROTOCOL});
-  }
 }

packages/plugin-file/sources/TarballFileResolver.ts

@@ -48,17 +48,16 @@ export class TarballFileResolver implements Resolver {
   }
 
   async getCandidates(descriptor: Descriptor, dependencies: unknown, opts: ResolveOptions) {
-    const locator = await this.getCandidateForDescriptor(descriptor, opts);
+    let path = descriptor.range;
+
+    if (path.startsWith(PROTOCOL))
+      path = path.slice(PROTOCOL.length);
 
-    return [locator];
+    return [structUtils.makeLocator(descriptor, `${PROTOCOL}${npath.toPortablePath(path)}`)];
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const {reference: tarballFileReference} = await this.getCandidateForDescriptor(descriptor, opts);
-
-    return references
-      .filter(reference => reference === tarballFileReference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions) {
@@ -88,13 +87,4 @@ export class TarballFileResolver implements Resolver {
       bin: manifest.bin,
     };
   }
-
-  private async getCandidateForDescriptor(descriptor: Descriptor, opts: ResolveOptions) {
-    let path = descriptor.range;
-
-    if (path.startsWith(PROTOCOL))
-      path = path.slice(PROTOCOL.length);
-
-    return structUtils.makeLocator(descriptor, `${PROTOCOL}${npath.toPortablePath(path)}`);
-  }
 }

packages/plugin-git/sources/GitResolver.ts

@@ -27,17 +27,14 @@ export class GitResolver implements Resolver {
   }
 
   async getCandidates(descriptor: Descriptor, dependencies: unknown, opts: ResolveOptions) {
-    const locator = await this.getCandidateForDescriptor(descriptor, opts);
+    const reference = await gitUtils.resolveUrl(descriptor.range, opts.project.configuration);
+    const locator = structUtils.makeLocator(descriptor, reference);
 
     return [locator];
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const {reference: gitReference} = await this.getCandidateForDescriptor(descriptor, opts);
-
-    return references
-      .filter(reference => reference === gitReference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions) {
@@ -67,11 +64,4 @@ export class GitResolver implements Resolver {
       bin: manifest.bin,
     };
   }
-
-  private async getCandidateForDescriptor(descriptor: Descriptor, opts: ResolveOptions) {
-    const reference = await gitUtils.resolveUrl(descriptor.range, opts.project.configuration);
-    const locator = structUtils.makeLocator(descriptor, reference);
-
-    return locator;
-  }
 }

packages/plugin-http/sources/TarballHttpResolver.ts

@@ -43,11 +43,7 @@ export class TarballHttpResolver implements Resolver {
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const tarballReference = structUtils.convertDescriptorToLocator(descriptor).reference;
-
-    return references
-      .filter(reference => reference === tarballReference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions) {

packages/plugin-link/sources/LinkResolver.ts

@@ -36,17 +36,13 @@ export class LinkResolver implements Resolver {
   }
 
   async getCandidates(descriptor: Descriptor, dependencies: unknown, opts: ResolveOptions) {
-    const locator = await this.getCandidateForDescriptor(descriptor, opts);
+    const path = descriptor.range.slice(LINK_PROTOCOL.length);
 
-    return [locator];
+    return [structUtils.makeLocator(descriptor, `${LINK_PROTOCOL}${npath.toPortablePath(path)}`)];
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const {reference: linkReference} = await this.getCandidateForDescriptor(descriptor, opts);
-
-    return references
-      .filter(reference => reference === linkReference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions): Promise<Package> {
@@ -76,10 +72,4 @@ export class LinkResolver implements Resolver {
       bin: manifest.bin,
     };
   }
-
-  private async getCandidateForDescriptor(descriptor: Descriptor, opts: ResolveOptions) {
-    const path = descriptor.range.slice(LINK_PROTOCOL.length);
-
-    return structUtils.makeLocator(descriptor, `${LINK_PROTOCOL}${npath.toPortablePath(path)}`);
-  }
 }

packages/plugin-link/sources/RawLinkResolver.ts

@@ -36,17 +36,13 @@ export class RawLinkResolver implements Resolver {
   }
 
   async getCandidates(descriptor: Descriptor, dependencies: unknown, opts: ResolveOptions) {
-    const locator = await this.getCandidateForDescriptor(descriptor, opts);
+    const path = descriptor.range.slice(RAW_LINK_PROTOCOL.length);
 
-    return [locator];
+    return [structUtils.makeLocator(descriptor, `${RAW_LINK_PROTOCOL}${npath.toPortablePath(path)}`)];
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const {reference: rawLinkReference} = await this.getCandidateForDescriptor(descriptor, opts);
-
-    return references
-      .filter(reference => reference === rawLinkReference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions) {
@@ -67,10 +63,4 @@ export class RawLinkResolver implements Resolver {
       bin: new Map(),
     };
   }
-
-  private async getCandidateForDescriptor(descriptor: Descriptor, opts: ResolveOptions) {
-    const path = descriptor.range.slice(RAW_LINK_PROTOCOL.length);
-
-    return structUtils.makeLocator(descriptor, `${RAW_LINK_PROTOCOL}${npath.toPortablePath(path)}`);
-  }
 }

packages/plugin-npm/sources/NpmTagResolver.ts

@@ -66,7 +66,7 @@ export class NpmTagResolver implements Resolver {
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
     // We can't statically know if a tag resolves to a specific version without using the network
-    return [];
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions): Promise<Package> {

packages/plugin-patch/sources/PatchResolver.ts

@@ -46,27 +46,6 @@ export class PatchResolver implements Resolver {
   }
 
   async getCandidates(descriptor: Descriptor, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const locator = await this.getCandidateForDescriptor(descriptor, dependencies, opts);
-
-    return [locator];
-  }
-
-  async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const {reference: patchReference} = await this.getCandidateForDescriptor(descriptor, dependencies, opts);
-
-    return references
-      .filter(reference => reference === patchReference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
-  }
-
-  async resolve(locator: Locator, opts: ResolveOptions): Promise<Package> {
-    const {sourceLocator} = patchUtils.parseLocator(locator);
-    const sourcePkg = await opts.resolver.resolve(sourceLocator, opts);
-
-    return {...sourcePkg, ...locator};
-  }
-
-  private async getCandidateForDescriptor(descriptor: Descriptor, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
     if (!opts.fetchOptions)
       throw new Error(`Assertion failed: This resolver cannot be used unless a fetcher is configured`);
 
@@ -79,6 +58,17 @@ export class PatchResolver implements Resolver {
 
     const patchHash = hashUtils.makeHash(`${CACHE_VERSION}`, ...patchFiles).slice(0, 6);
 
-    return patchUtils.makeLocator(descriptor, {parentLocator, sourcePackage, patchPaths, patchHash});
+    return [patchUtils.makeLocator(descriptor, {parentLocator, sourcePackage, patchPaths, patchHash})];
+  }
+
+  async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
+    return null;
+  }
+
+  async resolve(locator: Locator, opts: ResolveOptions): Promise<Package> {
+    const {sourceLocator} = patchUtils.parseLocator(locator);
+    const sourcePkg = await opts.resolver.resolve(sourceLocator, opts);
+
+    return {...sourcePkg, ...locator};
   }
 }

packages/yarnpkg-core/sources/LegacyMigrationResolver.ts

@@ -116,16 +116,7 @@ export class LegacyMigrationResolver implements Resolver {
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    if (!this.resolutions)
-      throw new Error(`Assertion failed: The resolution store should have been setup`);
-
-    const resolution = this.resolutions.get(descriptor.descriptorHash);
-    if (!resolution)
-      throw new Error(`Assertion failed: The resolution should have been registered`);
-
-    return references
-      .filter(reference => reference === resolution.reference)
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions): Promise<never> {

packages/yarnpkg-core/sources/LockfileResolver.ts

@@ -52,19 +52,7 @@ export class LockfileResolver implements Resolver {
   }
 
   async getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions) {
-    const convertedPkg = opts.project.originalPackages.get(structUtils.convertDescriptorToLocator(descriptor).locatorHash);
-
-    const resolution = opts.project.storedResolutions.get(descriptor.descriptorHash);
-    const resolutionPkg = typeof resolution !== `undefined`
-      ? opts.project.originalPackages.get(resolution)
-      : undefined;
-
-    return references
-      .filter(reference => [
-        convertedPkg?.reference,
-        resolutionPkg?.reference,
-      ].includes(reference))
-      .map(reference => structUtils.makeLocator(descriptor, reference));
+    return null;
   }
 
   async resolve(locator: Locator, opts: ResolveOptions) {

packages/yarnpkg-core/sources/Resolver.ts

@@ -138,12 +138,15 @@ export interface Resolver {
    * locators are first. This will cause the resolution algorithm to prioritize
    * them if possible (it doesn't guarantee that they'll end up being used).
    *
+   * If the operation is unsupported by the resolver (i.e. if it can't be statically
+   * determined which references satisfy the target descriptor), `null` should be returned.
+   *
    * @param descriptor The target descriptor.
    * @param references The candidate references.
    * @param dependencies The resolution dependencies and their resolutions.
    * @param opts The resolution options.
    */
-  getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions): Promise<Array<Locator>>;
+  getSatisfying(descriptor: Descriptor, references: Array<string>, dependencies: Map<DescriptorHash, Package>, opts: ResolveOptions): Promise<Array<Locator> | null>;
 
   /**
    * This function will, given a locator, return the full package definition