/// <inheritdoc />
public async Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
if (!string.Equals(module.Descriptor.ResolverName, Name, StringComparison.Ordinal))
{
return(null);
}
var package = CreatePackage(module.Definition);
Contract.Assert(module.Specs.Count == 1, "This resolver generated the module, so we expect a single spec.");
var sourceKv = module.Specs.First();
// The in-memory generated spec is a regular DScript one, so run regular AST conversion
var result = await FrontEndUtilities.RunAstConversionAsync(m_frontEndHost, m_context, m_logger, m_frontEndStatistics, package, sourceKv.Key);
if (!result.Success)
{
return(false);
}
// Register the uninstantiated module
var moduleData = new UninstantiatedModuleInfo(
result.SourceFile,
result.Module,
result.QualifierSpaceId.IsValid ? result.QualifierSpaceId : m_context.QualifierTable.EmptyQualifierSpaceId);
m_frontEndHost.ModuleRegistry.AddUninstantiatedModuleInfo(moduleData);
return(true);
}
private void ConvertExportsFile(IModuleRegistry moduleRegistry, ParsedModule module, Package package)
{
var exportsFileModule = ModuleLiteral.CreateFileModule(
m_javaScriptWorkspaceResolver.ExportsFile,
moduleRegistry,
package,
module.Specs[m_javaScriptWorkspaceResolver.ExportsFile].LineMap);
// For each symbol defined in the resolver settings for exports, add all specified project outputs
int pos = 1;
foreach (var export in Exports)
{
FrontEndUtilities.AddEvaluationCallbackToFileModule(
exportsFileModule,
(context, moduleLiteral, evaluationStackFrame) =>
CollectProjectOutputsAsync(module.Definition.Specs, moduleLiteral.Qualifier.QualifierId, export, context.EvaluationScheduler),
export.FullSymbol,
pos);
pos += 2;
}
var moduleInfo = new UninstantiatedModuleInfo(
// We can register an empty one since we have the module populated properly
new Script.SourceFile(
m_javaScriptWorkspaceResolver.ExportsFile,
new Declaration[] { }),
exportsFileModule,
Context.QualifierTable.EmptyQualifierSpaceId);
moduleRegistry.AddUninstantiatedModuleInfo(moduleInfo);
}
public void Write(BuildXLWriter writer, UninstantiatedModuleInfo module)
{
Contract.Requires(module.FileModuleLiteral != null, "Can serialize only file modules.");
module.FileModuleLiteral.Serialize(writer);
writer.Write(module.QualifierSpaceId);
}
private static void PopulatePredefinedModuleLiteralProperties(ModuleLiteral env, List <Property> properties, EvaluationContext context)
{
Contract.Requires(env != null);
Contract.Requires(context != null);
// TODO: path, package, and parent are not projectable from a module literal, but very useful for debugging.
if (env.IsFileModule)
{
// TODO:ST: hide module instantiation from the clients!
// This is last case when we need Id!
UninstantiatedModuleInfo moduleInfo = context.ModuleRegistry.GetUninstantiatedModuleInfoByModuleId(env.Id);
properties.AddRange(new[]
{
new Property(":path", env.Path.ToDisplayString(context)),
new Property(":package", env.Package),
new Property(":qualifierSpace", GetQualifierSpaceValue(context, moduleInfo.QualifierSpaceId)),
});
}
properties.Add(new Property(":parent", env.OuterScope));
if (env.IsFileModule)
{
properties.Add(new Property("qualifier", env.Qualifier.Qualifier));
}
}
/// <nodoc />
public UninstantiatedModuleInfo ReadModuleInfo(ModuleRegistry registry, BuildXLReader reader)
{
var module = FileModuleLiteral.Read(reader, m_pathTable, m_globalModule, registry);
var qualifierSpaceId = reader.ReadQualifierSpaceId();
var uninstantiatedModule = new UninstantiatedModuleInfo(null, module, qualifierSpaceId);
return(uninstantiatedModule);
}
/// <inheritdoc/>
protected override EvaluationResult DoEval(Context context, ModuleLiteral env, EvaluationStackFrame frame)
{
// To evaluate imported module following steps are required:
// 1. Find an instantiated module by path specifier (the module was already resolved during workspace computation,
// so no additional work is required here).
// 2. Coerce current qualifier with a qualifier defined in a target file.
// 3. Instantiate the module and return it.
UninstantiatedModuleInfo importedModuleInfo = context.ModuleRegistry.GetUninstantiatedModuleInfoByPath(m_referencedPath);
var module = importedModuleInfo.FileModuleLiteral.Instantiate(context.ModuleRegistry, env.Qualifier);
return(EvaluationResult.Create(module));
}
private async Task RunAstConverstionForFileAsync(Package package, AbsolutePath file)
{
var conversionResult = await FrontEndUtilities.RunAstConversionAsync(m_host, Context, m_logger, new FrontEndStatistics(), package, file);
Contract.Assert(conversionResult.Success);
var moduleData = new UninstantiatedModuleInfo(
conversionResult.SourceFile,
conversionResult.Module,
conversionResult.QualifierSpaceId.IsValid ? conversionResult.QualifierSpaceId : Context.QualifierTable.EmptyQualifierSpaceId);
m_host.ModuleRegistry.AddUninstantiatedModuleInfo(moduleData);
}
private FileModuleLiteral GetFileModuleInstanceFromImportOrExportDeclaration(
ModuleRegistry moduleRegistry,
AbsolutePath referencedPath)
{
var importedModuleId = ModuleLiteralId.Create(referencedPath);
// Get the uninstantiated version of this file module.
UninstantiatedModuleInfo importedModuleInfo = moduleRegistry.GetUninstantiatedModuleInfoByModuleId(importedModuleId);
// Evaluate qualifier if specified.
QualifierValue qualifierValue = Qualifier;
// Instantiate this file module according to the qualifier.
FileModuleLiteral importedModule = importedModuleInfo.FileModuleLiteral.InstantiateFileModuleLiteral(moduleRegistry, qualifierValue);
return(importedModule);
}
private async Task ConvertImportsFileAsync(Package package)
{
if (m_javaScriptWorkspaceResolver.CustomSchedulingCallback != null)
{
// The imports file does not need any special callbacks and it is regular DScript. Run the normal AST conversion process on it.
var conversionResult = await FrontEndUtilities.RunAstConversionAsync(m_host, Context, m_logger, new FrontEndStatistics(), package, m_javaScriptWorkspaceResolver.ImportsFile);
Contract.Assert(conversionResult.Success);
var moduleData = new UninstantiatedModuleInfo(
conversionResult.SourceFile,
conversionResult.Module,
conversionResult.QualifierSpaceId.IsValid ? conversionResult.QualifierSpaceId : Context.QualifierTable.EmptyQualifierSpaceId);
m_host.ModuleRegistry.AddUninstantiatedModuleInfo(moduleData);
}
}
/// <inheritdoc/>
public Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
// This resolver owns only one module.
if (!module.Definition.Equals(ModuleDefinition))
{
return(Task.FromResult <bool?>(null));
}
var exportsFileModule = ModuleLiteral.CreateFileModule(
m_javaScriptWorkspaceResolver.ExportsFile,
moduleRegistry,
FrontEndUtilities.CreatePackage(module.Definition, Context.StringTable),
module.Specs[m_javaScriptWorkspaceResolver.ExportsFile].LineMap);
// For each symbol defined in the resolver settings for exports, add all specified project outputs
int pos = 1;
foreach (var export in Exports)
{
FrontEndUtilities.AddEvaluationCallbackToFileModule(
exportsFileModule,
(context, moduleLiteral, evaluationStackFrame) =>
CollectProjectOutputsAsync(module.Definition.Specs, moduleLiteral.Qualifier.QualifierId, export),
export.FullSymbol,
pos);
pos += 2;
}
var moduleInfo = new UninstantiatedModuleInfo(
// We can register an empty one since we have the module populated properly
new SourceFile(
m_javaScriptWorkspaceResolver.ExportsFile,
new Declaration[] {}),
exportsFileModule,
Context.QualifierTable.EmptyQualifierSpaceId);
moduleRegistry.AddUninstantiatedModuleInfo(moduleInfo);
return(Task.FromResult <bool?>(true));
}
/// <inheritdoc />
public Task <bool?> TryConvertModuleToEvaluationAsync(IModuleRegistry moduleRegistry, ParsedModule module, IWorkspace workspace)
{
if (!string.Equals(module.Descriptor.ResolverName, Name, StringComparison.Ordinal))
{
return(Task.FromResult <bool?>(null));
}
var downloadData = m_workspaceResolver.Downloads[module.Descriptor.Name];
var package = CreatePackage(module.Definition);
Contract.Assert(module.Specs.Count == 1, "This resolver generated the module, so we expect a single spec.");
var sourceKv = module.Specs.First();
var sourceFilePath = sourceKv.Key;
var sourceFile = sourceKv.Value;
var currentFileModule = ModuleLiteral.CreateFileModule(
sourceFilePath,
moduleRegistry,
package,
sourceFile.LineMap);
// Download
var downloadSymbol = FullSymbol.Create(m_context.SymbolTable, "download");
var downloadResolvedEntry = new ResolvedEntry(
downloadSymbol,
(Context context, ModuleLiteral env, EvaluationStackFrame args) => DownloadFile(downloadData),
// The following position is a contract right now iwtht he generated ast in the workspace resolver
// we have to find a nicer way to handle and register these.
TypeScript.Net.Utilities.LineInfo.FromLineAndPosition(0, 1)
);
currentFileModule.AddResolvedEntry(downloadSymbol, downloadResolvedEntry);
currentFileModule.AddResolvedEntry(new FilePosition(1, sourceFilePath), downloadResolvedEntry);
// Contents.All
var extractedSymbol = FullSymbol.Create(m_context.SymbolTable, "extracted");
var contentsResolvedEntry = new ResolvedEntry(
extractedSymbol,
(Context context, ModuleLiteral env, EvaluationStackFrame args) => ExtractFile(downloadData),
// The following position is a contract right now iwtht he generated ast in the workspace resolver
// we have to find a nicer way to handle and register these.
TypeScript.Net.Utilities.LineInfo.FromLineAndPosition(0, 3)
);
currentFileModule.AddResolvedEntry(extractedSymbol, contentsResolvedEntry);
currentFileModule.AddResolvedEntry(new FilePosition(3, sourceFilePath), contentsResolvedEntry);
var moduleInfo = new UninstantiatedModuleInfo(
// We can register an empty one since we have the module populated properly
new SourceFile(
sourceFilePath,
new Declaration[]
{
}),
currentFileModule,
m_context.QualifierTable.EmptyQualifierSpaceId);
moduleRegistry.AddUninstantiatedModuleInfo(moduleInfo);
return(Task.FromResult <bool?>(true));
}
/// <summary>
/// Coerce source qualifier with a target one.
/// </summary>
public static bool CoerceQualifierValue(
Context context,
ModuleLiteral env,
QualifierSpaceId sourceQualifierSpaceId,
UninstantiatedModuleInfo targetModule,
in UniversalLocation referencingLocation,
/// <nodoc/>
public void AddUninstantiatedModuleInfo(UninstantiatedModuleInfo moduleInfo)
{
Contract.Requires(moduleInfo != null, "moduleInfo != null");
m_uninstantiatedModuleDictionary.TryAdd(moduleInfo.ModuleLiteral.Id, moduleInfo);
}
/// <nodoc/>
public bool TryGetUninstantiatedModuleInfoByPath(AbsolutePath path, out UninstantiatedModuleInfo result)
{
return(m_uninstantiatedModuleDictionary.TryGetValue(ModuleLiteralId.Create(path), out result));
}
