private Dictionary <AbsolutePath, ISourceFile> GetModuleConfigurationFiles()
{
var result = new Dictionary <AbsolutePath, ISourceFile>();
foreach (var resolver in m_resolvers)
{
foreach (var sf in resolver.GetAllModuleConfigurationFiles())
{
result[sf.GetAbsolutePath(PathTable)] = sf;
// This is yet another indication of an overly complicated design of the front-end
// There is no simple way to know what resolver responsible for configuration processing.
// We can keep the map for each path to resolver that produced it,
// but this still leaves an issue with main configuration file.
// So for now, we just use one of the resolvers that produced the config
// as a "configuration resolver".
if (m_configurationResolver == null)
{
m_configurationResolver = resolver;
}
}
}
return(result);
}
/// <inheritdoc/>
public bool TryCreateWorkspaceResolver(IResolverSettings resolverSettings, out IWorkspaceModuleResolver workspaceResolver)
{
workspaceResolver = m_workspaceResolverCache.GetOrAdd(
resolverSettings,
(settings) =>
{
IWorkspaceModuleResolver resolver;
if (string.Equals(resolverSettings.Kind, KnownResolverKind.DefaultSourceResolverKind, System.StringComparison.Ordinal))
{
resolver = new WorkspaceDefaultSourceModuleResolver(Context.StringTable, FrontEndStatistics, logger: m_customLogger);
}
else
{
resolver = new WorkspaceSourceModuleResolver(Context.StringTable, FrontEndStatistics, logger: m_customLogger);
}
if (resolver.TryInitialize(FrontEndHost, Context, Configuration, settings))
{
return(resolver);
}
return(null);
});
return(workspaceResolver != null);
}
/// <summary>
/// Creates a module from a module name and optionally a version using an id that it is guaranteed to be unique.
/// </summary>
public static ModuleDescriptor CreateWithUniqueId(string moduleName, IWorkspaceModuleResolver resolver, string version = null)
{
return(new ModuleDescriptor(
id: ModuleIdProvider.GetNextId(),
name: moduleName,
displayName: moduleName,
version: version,
resolverKind: resolver.Kind,
resolverName: resolver.Name));
}
/// <summary>
/// Returns the module definition that contains <param name="specPath"/> if such a module is known
/// to <param name="moduleResolver"/>
/// </summary>
public static async ValueTask <Possible <ModuleDefinition> > TryGetOwningModuleDefinitionAsync(
this IWorkspaceModuleResolver moduleResolver, AbsolutePath specPath)
{
var maybeName = await moduleResolver.TryGetOwningModuleDescriptorAsync(specPath);
if (maybeName.Succeeded)
{
return(await moduleResolver.TryGetModuleDefinitionAsync(maybeName.Result));
}
return(maybeName.Failure);
}
/// <inheritdoc/>
public bool TryCreateWorkspaceResolver(IResolverSettings resolverSettings, out IWorkspaceModuleResolver workspaceResolver)
{
workspaceResolver = m_workspaceResolverCache.GetOrAdd(
resolverSettings,
(settings) =>
{
var resolver = new WorkspaceNugetModuleResolver(Context.StringTable, FrontEndStatistics);
if (resolver.TryInitialize(FrontEndHost, Context, Configuration, settings))
{
return(resolver);
}
return(null);
});
return(workspaceResolver != null);
}
/// <inheritdoc />
public virtual bool TryCreateWorkspaceResolver(
[NotNull] IResolverSettings resolverSettings,
[NotNull] out IWorkspaceModuleResolver workspaceResolver)
{
workspaceResolver = m_workspaceResolverCache.GetOrAdd(
resolverSettings,
(settings) =>
{
var resolver = new TWorkspaceResolver();
if (resolver.TryInitialize(Host, Context, Configuration, settings))
{
return(resolver);
}
return(default(TWorkspaceResolver));
});
return(workspaceResolver != default(TWorkspaceResolver));
}
/// <summary>
/// Returns all the module definitions owned by this resolver.
/// </summary>
public static async Task <Possible <IReadOnlyCollection <ModuleDefinition> > > GetAllModuleDefinitionsAsync(this IWorkspaceModuleResolver moduleResolver)
{
var names = await moduleResolver.GetAllKnownModuleDescriptorsAsync();
if (!names.Succeeded)
{
return(names.Failure);
}
// We bail out on first failure
var moduleDefinitions = new List <ModuleDefinition>(names.Result.Count);
foreach (var name in names.Result)
{
var maybeModuleDefinition = await moduleResolver.TryGetModuleDefinitionAsync(name);
if (!maybeModuleDefinition.Succeeded)
{
return(maybeModuleDefinition.Failure);
}
moduleDefinitions.Add(maybeModuleDefinition.Result);
}
return(moduleDefinitions);
}
private ModuleDefinition CreateConfigModuleDefinition(AbsolutePath mainConfig, HashSet <AbsolutePath> allSpecs, IWorkspaceModuleResolver configurationResolver)
{
var descriptorName = Names.ConfigModuleName;
var mdsc = new ModuleDescriptor(
id: ModuleId.Create(PathTable.StringTable, descriptorName),
name: descriptorName,
displayName: descriptorName,
version: "0.0",
resolverKind: configurationResolver.Kind,
resolverName: configurationResolver.Name);
return(ModuleDefinition.CreateModuleDefinitionWithExplicitReferencesWithEmptyQualifierSpace(
descriptor: mdsc,
main: mainConfig,
moduleConfigFile: AbsolutePath.Invalid,
specs: allSpecs,
pathTable: PathTable));
}
/// <inheritdoc/>
public bool TryCreateWorkspaceResolver(IResolverSettings resolverSettings, out IWorkspaceModuleResolver workspaceResolver)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a module from a module name and optionally a version using an id that it is guaranteed to be unique.
/// </summary>
public static ModuleDescriptor CreateWithUniqueId(StringTable table, string moduleName, IWorkspaceModuleResolver resolver, string version = null)
{
return(new ModuleDescriptor(
id: ModuleId.Create(table, moduleName, version),
name: moduleName,
displayName: moduleName,
version: version,
resolverKind: resolver.Kind,
resolverName: resolver.Name));
}
