/// <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)); }