private async Task <Workspace> TypeCheckWorkspaceAsync(Workspace workspace)
{
var frontEndStatistics = new FrontEndStatistics(); // don't pollute global statistics with this
var semanticWorkspaceProvider = new SemanticWorkspaceProvider(frontEndStatistics, WorkspaceConfiguration);
workspace = await semanticWorkspaceProvider.ComputeSemanticWorkspaceAsync(Context.PathTable, workspace);
if (workspace.GetSemanticModel().GetAllSemanticDiagnostics().Any())
{
return(workspace.WithExtraFailures(new[] { new Failure <string>("Failed to type check configuration") }));
}
return(workspace);
}
private Workspace GetWorkspace(ModuleRepository moduleRepository)
{
var workspaceProvider = CreateWorkspaceProviderFromContent(false, moduleRepository);
var workspace = workspaceProvider.CreateWorkspaceFromAllKnownModulesAsync().GetAwaiter().GetResult();
var semanticWorkspaceProvider = new SemanticWorkspaceProvider(m_frontEndStatistics, workspace.WorkspaceConfiguration);
var semanticWorkspace = semanticWorkspaceProvider.ComputeSemanticWorkspaceAsync(PathTable, workspace).GetAwaiter().GetResult();
var semanticModel = semanticWorkspace.GetSemanticModel();
if (semanticModel.GetAllSemanticDiagnostics().Any())
{
var errors = string.Join("\r\n", semanticModel.GetAllSemanticDiagnostics());
XAssert.Fail("Semantic model is expected to be error free. Errors found " + errors);
}
return(semanticWorkspace);
}
/// <nodoc/>
public Expression ParseExpression(RuntimeModelContext runtimeModelContext, AbsolutePath path, string spec, FunctionScope localScope, bool useSemanticNameResolution)
{
Contract.Requires(runtimeModelContext != null);
Contract.Requires(spec != null);
var parser = new TypeScript.Net.Parsing.Parser();
// Wrap expression in a function call to make the parser happy.
// Currently an object literal '{...};' is not a valid statement.
var sourceFile = parser.ParseSourceFileContent(
path.ToString(runtimeModelContext.PathTable),
@"function createExpression(a: any) {}
createExpression(" + spec + ");");
if (sourceFile.ParseDiagnostics.Count != 0)
{
ReportParseDiagnosticsIfNeeded(runtimeModelContext, sourceFile, path);
return(null);
}
var workspaceConfiguration = WorkspaceConfiguration.CreateForTesting();
var workspace = new Workspace(
provider: null,
workspaceConfiguration: workspaceConfiguration,
modules: new[] { CreateModuleFor(runtimeModelContext, sourceFile) },
failures: Enumerable.Empty <Failure>(),
preludeModule: null,
configurationModule: null);
workspace = SemanticWorkspaceProvider.ComputeSemanticWorkspace(runtimeModelContext.PathTable, workspace, workspaceConfiguration).GetAwaiter().GetResult();
// Because we just created source file to parse, we know exactly what the AST is there.
// This information helped to simplify analysis logic and migrate to semantic-base name resolution.
var invocation = sourceFile.Statements[1].Cast <IExpressionStatement>().Expression.Cast <ICallExpression>();
// Only for expressions, full names should be preserved.
// Only for expressions, no checks for definition before use to avoid contract assertion in location computation.
m_conversionConfiguration.UnsafeOptions.DisableDeclarationBeforeUseCheck = true;
var converter = CreateAstConverter(sourceFile, runtimeModelContext, path, m_conversionConfiguration, workspace: workspace);
return(converter.ConvertExpression(invocation, localScope, useSemanticNameResolution));
}
/// <summary>
/// Creates a semantic workspace from the given moduleRepositories. If <paramref name="initialModule"/> is specified,
/// the workspace will contain only those modules required by the <paramref name="initialModule"/> module; otherwise,
/// the workspace will contain all known modules.
/// </summary>
/// <remarks>
/// Consider that if modules are not unique across the array, the file system will be given the union of the specs
/// that belong to the same module in some order.
/// </remarks>
public async Task <Workspace> CreateSematicWorkspaceFromContent(
ModuleDescriptor?initialModule,
bool preserveTrivia = false,
params ModuleRepository[] moduleRepositoryArray)
{
var workspaceProvider = CreateWorkspaceProviderFromContent(preserveTrivia: preserveTrivia, moduleRepositoryArray: moduleRepositoryArray);
var workspace = initialModule != null
? await workspaceProvider.CreateWorkspaceFromModuleAsync(initialModule.Value)
: await workspaceProvider.CreateWorkspaceFromAllKnownModulesAsync();
if (!workspace.Succeeded)
{
Assert.True(
false,
"Error building workspace:" +
Environment.NewLine +
string.Join(
Environment.NewLine,
workspace.Failures.Select(
f =>
{
var parseFail = f as ParsingFailure;
if (parseFail != null)
{
return(f.Describe() + string.Join(Environment.NewLine, parseFail.ParseDiagnostics.Select(d => d.ToString())));
}
return(f.Describe());
})));
}
var sematicWorkspaceProvider = new SemanticWorkspaceProvider(workspaceProvider.Statistics, workspaceProvider.Configuration);
var sematicWorkspace = await sematicWorkspaceProvider.ComputeSemanticWorkspaceAsync(PathTable, workspace);
return(sematicWorkspace);
}
private Task <Workspace> ComputeSemanticWorkspaceAsync(Workspace workspace, WorkspaceConfiguration workspaceConfiguration)
{
var semanticWorkspaceProvider = new SemanticWorkspaceProvider(m_frontEndStatistics, workspaceConfiguration);
return(semanticWorkspaceProvider.ComputeSemanticWorkspaceAsync(FrontEndContext.PathTable, workspace));
}
private Workspace GetUpdatedWorkspace(ParsedModule parsedModule, ModuleDefinition moduleDefinition, AbsolutePath path)
{
// Need to use both 'ParsedModule' and 'ModuleDefinition' in case if the 'path' is newly added
// file and was not parsed yet.
// All already parsed modules are good to go
var unchangedModules = m_workspace.SpecModules;
// We build a module under construction that has all specs but the one that changed
var moduleUnderConstruction = new ModuleUnderConstruction(moduleDefinition);
foreach (var spec in parsedModule.Specs)
{
if (spec.Key != path)
{
moduleUnderConstruction.AddParsedSpec(spec.Key, spec.Value);
}
}
// Update parsing failures so the ones coming from the changed spec are removed
var filteredFailures = m_workspace.Failures.Where(
failure => (failure is ParsingFailure parsingFailure && parsingFailure.SourceFile.Path.AbsolutePath != path.ToString(m_pathTable)));
var updatedWorkspace =
m_workspace.WorkspaceProvider.CreateIncrementalWorkspaceForAllKnownModulesAsync(
unchangedModules,
moduleUnderConstruction,
filteredFailures,
m_workspace.PreludeModule)
.GetAwaiter()
.GetResult();
var semanticWorkspaceProvider = new SemanticWorkspaceProvider(new WorkspaceStatistics(), m_workspace.WorkspaceConfiguration);
var semanticWorkspace =
semanticWorkspaceProvider.ComputeSemanticWorkspaceAsync(m_pathTable, updatedWorkspace, m_workspace.GetSemanticModel(), incrementalMode: true)
.GetAwaiter()
.GetResult();
// Get all the potentially new specs. Old ones, besides the one that changed, were aready linted
var newPathToSpecs =
updatedWorkspace.GetAllSpecFiles()
.Except(m_workspace.GetAllSpecFiles())
.Concat(new[] { path });
// The changed spec always needs linting. Plus all the new ones the changed spec may have introduced.
var preludeModule = updatedWorkspace.PreludeModule;
var specsToLint = new HashSet <ISourceFile>();
foreach (var pathToSpec in newPathToSpecs)
{
// Need to exclude prelude files from liinting.
// Need to keep config files. They should be linted.
if (preludeModule == null || !preludeModule.Specs.ContainsKey(pathToSpec))
{
specsToLint.Add(updatedWorkspace.GetSourceFile(pathToSpec));
}
}
var lintedWorkspace = WorkspaceBuilder.CreateLintedWorkspaceForChangedSpecs(
semanticWorkspace,
specsToLint,
m_controller.FrontEndContext.LoggingContext,
m_controller.FrontEndConfiguration,
m_controller.FrontEndContext.PathTable);
return(lintedWorkspace);
}
