/// <nodoc />
public UninstantiatedModuleInfo(SourceFile sourceFile, [NotNull] FileModuleLiteral fileModuleLiteral, QualifierSpaceId qualifierSpaceId)
: this(sourceFile, qualifierSpaceId)
{
Contract.Requires(fileModuleLiteral != null, "fileModuleLiteral != null");
FileModuleLiteral = fileModuleLiteral;
}
/// <nodoc />
protected ContextTree CreateContext(
FileModuleLiteral instantiatedModule,
IEvaluationScheduler evaluationScheduler,
IDecorator <EvaluationResult> decorator,
EvaluatorConfiguration configuration,
FileType fileType)
{
Contract.Requires(instantiatedModule != null);
Contract.Requires(evaluationScheduler != null);
return(new ContextTree(
FrontEndHost,
Context,
Constants,
SharedModuleRegistry,
Logger,
Statistics,
qualifierValueCache: QualifierValueCache,
isBeingDebugged: IsBeingDebugged,
decorator: decorator,
module: instantiatedModule,
configuration: configuration,
evaluationScheduler: evaluationScheduler,
fileType: fileType));
}
/// <nodoc />
public DeserializationContext(FileModuleLiteral currentFile, BuildXLReader reader, PathTable pathTable, LineMap lineMap)
{
LineMap = lineMap;
CurrentFile = currentFile;
Reader = reader;
PathTable = pathTable;
}
private ObjectLiteral EvaluateConfigObjectLiteral(FileModuleLiteral moduleLiteral)
{
// Instantiate config module, and because config is qualifier-agnositic, it is instantiated with empty qualifier.
var instantiatedModule = InstantiateModuleWithDefaultQualifier(moduleLiteral);
// Decide here whether to use decoration for the config evaluation phase.
// Let's say no decorators allowed at this stage.
IDecorator <EvaluationResult> decoratorForConfig = null;
// Create an evaluation context tree and root context.
using (var contextTree = CreateContext(instantiatedModule, decoratorForConfig, EvaluatorConfigurationForConfig, FileType.GlobalConfiguration))
{
var context = contextTree.RootContext;
if (instantiatedModule.IsEmpty)
{
return(null);
}
// Note: Blocking on evaluation
var success = instantiatedModule.EvaluateAllAsync(context, VisitedModuleTracker.Disabled).GetAwaiter().GetResult();
if (!success)
{
// Error has been reported during the evaluation.
return(null);
}
return(ResolveConfigObjectLiteral(instantiatedModule, context));
}
}
private static IAstConverter CreateAstConverter(ISourceFile sourceFile, FileModuleLiteral module,
RuntimeModelContext runtimeModelContext, AbsolutePath specPath, AstConversionConfiguration conversionConfiguration, Workspace workspace)
{
var conversionContext = new AstConversionContext(runtimeModelContext, specPath, sourceFile, module);
return(AstConverter.Create(runtimeModelContext.QualifierTable, conversionContext, conversionConfiguration, workspace));
}
public void TestResolvedFileModuleLiteral()
{
FileModuleLiteral node = new FileModuleLiteral(GetAbsolutePath(), GetQualifierValue(), GlobalModuleLiteral, GetPackage(), ModuleRegistry, GetLineMap());
node.AddResolvedEntry(GetFullSymbol(), new ResolvedEntry(GetFullSymbol(), GetExpression1()));
TestFileModuleLiteralOrAbove(node, typeof(FileModuleLiteral));
}
internal PackageConfigParseResult(
SourceFile sourceFile,
FileModuleLiteral module,
QualifierSpaceId qualifierSpaceId,
SymbolAtom configurationKeyword)
: base(sourceFile, module, qualifierSpaceId)
{
ConfigurationKeyword = configurationKeyword;
}
internal SourceFileParseResult(SourceFile sourceFile, FileModuleLiteral module, QualifierSpaceId qualifierSpaceId)
: base(sourceFile)
{
Contract.Requires(sourceFile != null || module != null, "sourceFile or module should not be null");
SourceFile = sourceFile;
Module = module;
QualifierSpaceId = qualifierSpaceId;
}
/// <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);
}
/// <nodoc />
public static SourceFileParseResult Read(BuildXLReader reader, GlobalModuleLiteral outerScope, ModuleRegistry moduleRegistry, PathTable pathTable)
{
var moduleLiteral = FileModuleLiteral.Read(reader, pathTable, outerScope, moduleRegistry);
var context = new DeserializationContext(moduleLiteral, reader, pathTable, moduleLiteral.LineMap);
var sourceFile = new SourceFile(AbsolutePath.Invalid, CollectionUtilities.EmptyArray <Declaration>());
var qualifierSpaceId = context.Reader.ReadQualifierSpaceId();
return(new SourceFileParseResult(sourceFile, moduleLiteral, qualifierSpaceId));
}
public AstConversionContext(
RuntimeModelContext runtimeModelContext,
AbsolutePath currentSpecPath,
ISourceFile currentSourceFile,
FileModuleLiteral currentFileModule)
{
RuntimeModelContext = runtimeModelContext;
CurrentSpecPath = currentSpecPath;
CurrentSourceFile = currentSourceFile;
CurrentFileModule = currentFileModule;
}
protected void RegisterSuccessfullyParsedModule(SourceFile sourceFile, FileModuleLiteral moduleLiteral, Package package)
{
Contract.Requires(moduleLiteral != null);
Contract.Requires(package != null);
var moduleData = new UninstantiatedModuleInfo(
sourceFile,
moduleLiteral,
Context.QualifierTable.EmptyQualifierSpaceId);
RegisterModuleData(moduleData);
}
/// <nodoc />
protected ContextTree CreateContext(
FileModuleLiteral instantiatedModule,
IDecorator <EvaluationResult> decorator,
EvaluatorConfiguration configuration,
FileType fileType)
{
return(CreateContext(
instantiatedModule,
FrontEndHost.DefaultEvaluationScheduler,
decorator,
configuration,
fileType));
}
public ContextTree(
[NotNull] FrontEndHost frontEndHost,
[NotNull] FrontEndContext frontEndContext,
[NotNull] GlobalConstants constants,
[NotNull] ModuleRegistry moduleRegistry,
[NotNull] Logger logger,
[NotNull] EvaluationStatistics statistics,
QualifierValueCache qualifierValueCache,
bool isBeingDebugged,
IDecorator <EvaluationResult> decorator,
[NotNull] FileModuleLiteral module,
[NotNull] EvaluatorConfiguration configuration,
[NotNull] IEvaluationScheduler evaluationScheduler,
FileType fileType)
{
Contract.Requires(frontEndHost != null);
Contract.Requires(frontEndContext != null);
Contract.Requires(constants != null);
Contract.Requires(moduleRegistry != null);
Contract.Requires(logger != null);
Contract.Requires(statistics != null);
Contract.Requires(module != null);
EvaluationScheduler = evaluationScheduler;
FrontEndHost = frontEndHost;
FrontEndContext = frontEndContext;
Constants = constants;
ModuleRegistry = moduleRegistry;
Logger = logger;
Statistics = statistics;
IsBeingDebugged = isBeingDebugged;
Decorator = decorator;
EvaluationScheduler = evaluationScheduler;
QualifierValueCache = qualifierValueCache;
ToolDefinitionCache = new ConcurrentDictionary <ObjectLiteral, CachedToolDefinition>();
ValueCache = new ConcurrentDictionary <Fingerprint, EvaluationResult>();
CommonConstants = new CommonConstants(frontEndContext.StringTable);
RootContext =
new Context(
contextTree: this,
parent: null,
module: module,
topLevelValueInfo: null,
fileType: fileType,
configuration: configuration,
evaluationScheduler: evaluationScheduler);
Interlocked.Increment(ref statistics.ContextTrees);
}
/// <summary>
/// Parses, validates, and converts a given configuration file for the purpose of getting the configuration object.
/// </summary>
public async Task <ConfigConversionResult> ParseValidateAndConvertConfigFileAsync(AbsolutePath configPath)
{
var configStatistics = FrontEndStatistics.LoadConfigStatistics;
using (configStatistics.TotalDuration.Start())
{
Workspace workspace;
using (configStatistics.ParseDuration.Start())
{
workspace = await ParseAndValidateConfigFileAsync(configPath, typecheck : true);
if (workspace == null)
{
return(new ConfigConversionResult(Logger.ErrorCount));
}
}
if (!workspace.Succeeded)
{
ReportErrorDiagnostics(workspace.GetAllParsingAndBindingErrors());
ReportErrorDiagnostics(workspace.GetSemanticModel()?.GetAllSemanticDiagnostics());
ReportConfigParsingFailed(workspace.Failures.Select(f => f.Describe()));
return(new ConfigConversionResult(workspace.Failures.Count));
}
// convert every spec in the workspace
IReadOnlyCollection <FileModuleLiteral> convertedModules;
using (configStatistics.ConversionDuration.Start())
{
convertedModules = ConvertWorkspaceInParallel(workspace, configPath);
if (Logger.HasErrors)
{
return(new ConfigConversionResult(Logger.ErrorCount));
}
}
configStatistics.FileCountCounter.Increment(workspace.AllSpecCount);
FileModuleLiteral configModule = convertedModules.First(m => m.Path == configPath);
SymbolAtom configKeyword = GetConfigKeyword(workspace.ConfigurationModule.Specs[configPath].SourceFile);
return(new ConfigConversionResult(configModule, configKeyword));
}
}
/// <summary>
/// Adds a callback for a particular symbol that will be called
/// at evaluation time when that symbol is evaluated.
/// </summary>
/// <remarks>
/// Useful for programmatically executing customized evaluation for non-DScript
/// resolvers
/// </remarks>
public static void AddEvaluationCallbackToFileModule(
FileModuleLiteral fileModule,
Func <Context, ModuleLiteral, EvaluationStackFrame, Task <EvaluationResult> > evaluationCallback,
FullSymbol symbol,
int position)
{
var sourceFilePath = fileModule.Path;
var outputResolvedEntry = new ResolvedEntry(
symbol,
(Context context, ModuleLiteral env, EvaluationStackFrame args) => evaluationCallback(context, env, args),
// The following position is a contract right now with 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, position)
);
fileModule.AddResolvedEntry(symbol, outputResolvedEntry);
fileModule.AddResolvedEntry(new FilePosition(position, sourceFilePath), outputResolvedEntry);
}
public AstConversionContext(
RuntimeModelContext runtimeModelContext,
AbsolutePath currentSpecPath,
ISourceFile currentSourceFile,
FileModuleLiteral currentFileModule)
{
RuntimeModelContext = runtimeModelContext;
CurrentSpecPath = currentSpecPath;
CurrentSourceFile = currentSourceFile;
CurrentFileModule = currentFileModule;
QualifierDeclarationKeyword = CreateSymbol(Constants.Names.CurrentQualifier);
WithQualifierKeyword = CreateSymbol(Constants.Names.WithQualifierFunction);
UndefinedLiteral = CreateSymbol(Constants.Names.Undefined);
LegacyPackageKeyword = CreateSymbol(Constants.Names.LegacyModuleConfigurationFunctionCall);
ModuleKeyword = CreateSymbol(Constants.Names.ModuleConfigurationFunctionCall);
TemplateReference = CreateSymbol(Constants.Names.TemplateReference);
RuntimeRootNamespaceSymbol = CreateSymbol(Constants.Names.RuntimeRootNamespaceAlias);
}
/// <summary>
/// Tries to get a resolved (cached) function and module literal for a current Functor.
/// </summary>
private bool TryGetFunctionToInvoke(Context context, ModuleLiteral env, out FunctionLikeExpression function, out FileModuleLiteral file)
{
// When decorators are supported, no optimizations should be used.
var qualifierId = env.Qualifier.QualifierId.Id;
if (context.HasDecorator || qualifierId >= MaxQualifierId)
{
function = null;
file = null;
return(false);
}
// If the Functor is a regular named function call (i.e. FooBar in <code>function fooBar() {} const x = fooBar();</code>
// Then we can resolve the function once and cache it, but we have to obtain the 'file literal'
// that represents the target file for each qualifier.
// That's why there is a single value for function and an array for module literals.
file = m_fileLiterals[qualifierId];
if (file != null)
{
// This is only possible when the function was already resolved at least once.
function = m_functionToInvoke;
return(function != null);
}
// The cache is cold. Resolving the function if possible.
if (Functor is LocationBasedSymbolReference locationBased)
{
locationBased.TryResolveFunction(context, env, out function, out file);
if (function != null && file != null)
{
m_fileLiterals[qualifierId] = file;
m_functionToInvoke = function;
return(true);
}
}
function = null;
return(false);
}
private void TestFileModuleLiteralOrAbove(FileModuleLiteral node, Type type)
{
using (var ms = new MemoryStream())
{
using (var writer = new BuildXLWriter(false, ms, true, false))
using (var reader = new BuildXLReader(true, ms, true))
{
// Serialize
node.Serialize(writer);
// Copy for validation
byte[] firstPass = ms.ToArray();
// Reset the stream pointer to the start for deserializing
ms.Position = 0;
// Deserialize
DeserializationContext context = new DeserializationContext(null, reader, m_pathTable, node.LineMap);
var node2 = FileModuleLiteral.Read(reader, context.PathTable, GlobalModuleLiteral, ModuleRegistry);
Assert.NotNull(node2);
// Reset the stream pointer to the start for serializing
ms.Position = 0;
// Reserialize
node2.Serialize(writer);
// Copy for validation
byte[] secondPass = ms.ToArray();
// Compare byte arrays
Assert.Equal(firstPass, secondPass);
// Compare ASTs
ConstructorTests.ValidateEqual(null, type, node, node2, nameof(type), null);
}
}
}
/// <nodoc/>
public bool TryGetInstantiatedModule(QualifiedModuleId moduleKey, out FileModuleLiteral qualifiedFileModule)
{
return(m_moduleDictionary.TryGetValue(moduleKey, out qualifiedFileModule));
}
/// <summary>
/// Resolve a current location-based reference as <see cref="FunctionLikeExpression"/>.
/// </summary>
/// <remarks>
/// This method is used to resolve a function once and use it for all the invocations.
/// </remarks>
internal bool TryResolveFunction(Context context, ModuleLiteral env, out FunctionLikeExpression function, out FileModuleLiteral file)
{
return(env.TryResolveFunction(context, FilePosition, m_fullSymbol, out function, out file));
}
protected FileModuleLiteral InstantiateModule(FileModuleLiteral module, QualifierValue qualifier)
{
return(module.InstantiateFileModuleLiteral(SharedModuleRegistry, qualifier));
}
internal PackageConfigParseResult(SourceFile sourceFile, FileModuleLiteral module, SymbolAtom configurationKeyword)
: this(sourceFile, module, QualifierSpaceId.Invalid, configurationKeyword)
{
}
public void TestFileModuleLiteral()
{
FileModuleLiteral node = GetFileModuleLiteral();
TestFileModuleLiteralOrAbove(node, typeof(FileModuleLiteral));
}
protected FileModuleLiteral InstantiateModule(FileModuleLiteral module, QualifierValue qualifier)
{
return(module.InstantiateFileModuleLiteral(FrontEndHost.ModuleRegistry, qualifier));
}
protected FileModuleLiteral InstantiateModuleWithDefaultQualifier(FileModuleLiteral module)
{
return(module.InstantiateFileModuleLiteral(FrontEndHost.ModuleRegistry, EmptyQualifier));
}
