public async Task Invoke(HttpContext context)
{
var suaveContext = await context.ToSuaveHttpContext(_preserveHttpHeaderCasing);
var asyncWorkflow = _app.Invoke(suaveContext);
var result = await FSharpAsync.StartAsTask(
asyncWorkflow,
FSharpOption<TaskCreationOptions>.Some(TaskCreationOptions.None),
FSharpOption<CancellationToken>.Some(CancellationToken.None));
// Set the Suave result if the request could be handled by Suave
if (FSharpOption<Http.HttpContext>.get_IsSome(result))
{
await context.SetResponseFromSuaveResult(result.Value.response);
}
else
{
await _next.Invoke(context);
}
}
public async Task TargetMethodReturningFailingFSharpAsync_CanBeInvokedViaExecute()
{
// Arrange
var executor = GetExecutorForMethod("FSharpAsyncFailureMethod");
// Act
var fsharpAsync = (FSharpAsync <string>)executor.Execute(_targetObject, new object[] { "test result" });
var resultTask = FSharpAsync.StartAsTask(fsharpAsync,
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None);
// Assert
Assert.True(executor.IsMethodAsync);
Assert.Same(typeof(string), executor.AsyncResultType);
var exception = await Assert.ThrowsAsync <AggregateException>(async() => await resultTask);
Assert.IsType <InvalidOperationException>(exception.InnerException);
Assert.Equal("Test exception", exception.InnerException.Message);
}
public static async FAsync <string> DirectThrowCatch()
{
await FSharpAsync.Sleep(1);
string str = "unset";
try
{
if (int.Parse("1") > 0)
{
throw new SpecialException("direct");
}
str = "impossible";
}
catch (SpecialException ex) when(ex.Message == "direct")
{
str = "caught";
}
return(str);
}
TryParseAsync(string path, ISourceText sourceText, CancellationToken token)
{
if (parseOpts == null)
{
var defaults = FSharpParsingOptions.Default;
this.parseOpts = new FSharpParsingOptions(
sourceFiles: new string[] { path },
conditionalCompilationDefines: defaults.ConditionalCompilationDefines,
errorSeverityOptions: defaults.ErrorSeverityOptions,
isInteractive: defaults.IsInteractive,
lightSyntax: defaults.LightSyntax,
compilingFsLib: defaults.CompilingFsLib,
isExe: defaults.IsExe
);
}
var parseAsync = _provider.CheckerInstance.ParseFile(path, sourceText, parseOpts, "FsLint");
var parseResults = await FSharpAsync.StartAsTask(parseAsync, null, token).ConfigureAwait(false);
return(parseResults, null);
}
private static Mock <ICachingHttpClientDependencies> BuildDependencies()
{
var dependencies = new Mock <ICachingHttpClientDependencies>();
dependencies
.Setup(x => x.Cache.Get(It.IsAny <string>()))
.Returns(FSharpAsync.AwaitTask(Task.FromResult(FSharpOption <CachedValues> .None)));
dependencies
.Setup(x => x.Cache.Put(It.IsAny <Tuple <string, CachedValues> >()))
.Returns(FSharpAsync.AwaitTask(Task.FromResult(AppTestUtils.unit)));
dependencies
.Setup(x => x.Cache.Delete(It.IsAny <string>()))
.Returns(FSharpAsync.AwaitTask(Task.FromResult(AppTestUtils.unit)));
dependencies
.Setup(x => x.Cache.BuildUserKey(It.IsAny <CachedRequest.CachedRequest>()))
.Returns <CachedRequest.CachedRequest>(GetUserKey);
return(dependencies);
}
public static async FAsync <string> Catcher()
{
await FSharpAsync.Sleep(1);
await Task.Delay(1);
string result;
try
{
result = await Thrower();
}
catch (SpecialException ex) when(ex.Message == "bad")
{
result = "good";
}
catch (Exception)
{
Console.WriteLine("some other exn");
result = "misc";
}
return(result);
}
static void Main(string[] args)
{
FSharpChecker fSharpChecker = FSharpChecker.Create(null, null, null, null, null, null, null, null);
var fullPath = Path.GetFullPath("..\\..\\..\\..\\..\\boolMutateTestApp\\boolMutateTestApp\\Program.fs");
var sourceCode = File.ReadAllText(fullPath);
Tuple <FSharpProjectOptions, FSharpList <FSharpErrorInfo> > fsharpoptions = FSharpAsync.RunSynchronously(fSharpChecker.GetProjectOptionsFromScript(fullPath, SourceText.ofString(sourceCode), null, null, null, null, null, null, null, null, null), null, null);
FSharpParseFileResults result = FSharpAsync.RunSynchronously(fSharpChecker.ParseFile(fullPath, SourceText.ofString(sourceCode), fSharpChecker.GetParsingOptionsFromProjectOptions(fsharpoptions.Item1).Item1, null), null, null);
var syntaxTree = result.ParseTree;
if (syntaxTree.Value.IsImplFile)
{
var test = ((ImplFile)syntaxTree.Value).Item;
VisitModulesAndNamespaces(test.modules);
}
else
{
Console.WriteLine("F# Interface file (*.fsi) not supported.");
}
//fSharpChecker.CompileToDynamicAssembly()
// FSharpAsync<Tuple<FSharpErrorInfo[], int>> Compile(FSharpList<SyntaxTree.ParsedInput> ast, string assemblyName, string outFile, FSharpList<string> dependencies, [OptionalArgument] FSharpOption<string> pdbFile, [OptionalArgument] FSharpOption<bool> executable, [OptionalArgument] FSharpOption<bool> noframework, [OptionalArgument] FSharpOption<string> userOpName);
}
public async Task Invoke(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception ex)
{
try
{
var suaveContext = await context.ToSuaveHttpContext(_preserveHttpHeaderCasing);
var asyncWorkflow = _errorHandler.Invoke(ex).Invoke("").Invoke(suaveContext);
var result = await FSharpAsync.StartAsTask(
asyncWorkflow,
FSharpOption <TaskCreationOptions> .Some(TaskCreationOptions.None),
FSharpOption <CancellationToken> .Some(CancellationToken.None));
// Set the Suave result if the request could be handled by Suave and return
if (FSharpOption <Http.HttpContext> .get_IsSome(result))
{
await context.SetResponseFromSuaveResult(result.Value.response);
return;
}
}
catch (Exception ex2)
{
_logger.LogError(0, ex, $"An unhandled exception has occured: {ex.Message}.");
_logger.LogError(0, ex2, $"An exception was thrown attempting to execute the error handler: {ex2.Message}.");
}
// Re -throw the original exception
throw;
}
}
/// <summary>
/// Prevents dead locks when waiting for FCS while under write lock.
/// FCS may request a read lock from a background thread before processing this request.
/// We grant read access by passing the write lock.
/// </summary>
private static T RunTransferringWriteLock <T>(FSharpAsync <T> async)
{
var shellLocks = Shell.Instance.GetComponent <IShellLocks>();
shellLocks.AssertWriteAccessAllowed();
var task = FSharpAsync.StartAsTask(async, null, null);
var isLockTransferred = false;
while (!task.IsCompleted || isLockTransferred)
{
var finished = task.Wait(InterruptCheckTimeout, ourEternalCancellationToken);
if (finished)
{
if (!isLockTransferred)
{
break;
}
Thread.Sleep(GetTransferredWriteLockTimeout);
}
if (!isLockTransferred && FSharpLocks.ThreadRequestingWriteLock != null)
{
isLockTransferred = true;
shellLocks.ContentModelLocks.TransferWriteLock(FSharpLocks.ThreadRequestingWriteLock);
}
if (isLockTransferred && shellLocks.IsWriteAccessAllowed())
{
isLockTransferred = false;
}
}
return(task.Result);
}
public static Assembly Compile(string source)
{
var fileHelpersAssembly = typeof(EngineBase).Assembly;
var checker = FSharpChecker.Create(FSharpOption <int> .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None,
FSharpOption <ReferenceResolver.Resolver> .None,
FSharpOption <FSharpFunc <Tuple <string, DateTime>, FSharpOption <Tuple <object, IntPtr, int> > > > .None);
var file = Path.GetTempFileName();
File.WriteAllText(file + ".fs", source);
var action = checker.CompileToDynamicAssembly(new[] { "-o", file + ".dll", "-a", file + ".fs", "--reference:" + fileHelpersAssembly.Location },
FSharpOption <Tuple <TextWriter, TextWriter> > .None,
FSharpOption <string> .None);
var(compilationErrors, exitCode, assembly) = FSharpAsync
.StartAsTask(action, FSharpOption <TaskCreationOptions> .None, FSharpOption <CancellationToken> .None)
.Result;
if (compilationErrors.Any() && exitCode != 0)
{
var errors = new StringBuilder();
foreach (var error in compilationErrors)
{
errors.AppendLine(error.ToString());
}
throw new InvalidOperationException($"Cannot compile fsharp: {errors}");
}
return(assembly.Value);
}
public static async Task SendToInfluxAsync(this FSharpAsync <Candlestick[]> data, string connectionString, string database, CancellationToken token)
{
var batches = FSharpAsync.RunSynchronously(data, FSharpOption <int> .None, token)
// Evaluate:
.Batch(100)
// Convert each Batch into a LineProtocolPayload:
.Select(item => item.Convert());
foreach (var batch in batches)
{
try
{
var result = await WriteAsync(connectionString, database, batch, token);
// Log all unsuccessful writes, but do not quit execution:
if (!result.Success)
{
}
}
catch (Exception e)
{
}
}
}
/// <summary>
/// Clears the state (keeps the mailbox items)
/// </summary>
public Unit Restart()
{
lock (actorLock)
{
// Take a copy of the messages from the dead mailbox
var msgs = new Queue <UserControlMessage>(userMailbox.CurrentQueueLength);
while (userMailbox.CurrentQueueLength > 0)
{
UserControlMessage userMessage = FSharpAsync.StartAsTask(
userMailbox.Receive(FSharpOption <int> .None),
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None
).Result;
if (userMessage != null)
{
msgs.Enqueue(userMessage);
}
}
// We shutdown the children, because we're about to restart which will
// recreate them.
Shutdown(false);
// Start new mailboxes
StartMailboxes();
// Copy the old messages
while (msgs.Count > 0)
{
userMailbox.Post(msgs.Dequeue());
}
return(unit);
}
}
// Execute a command, as Decide(Action) does, but also yield an outcome from the decision public async Task <T> Decide <T>(Func <Context <TEvent, TState>, T> interpret) => await FSharpAsync.StartAsTask <T>(Decide(FuncConvert.FromFunc(interpret)), null, null);
// Run the decision method, letting it decide whether or not the Command's intent should manifest as Events public async Task <Unit> Execute(Action <Context <TEvent, TState> > decide) => await FSharpAsync.StartAsTask(Decide(FuncConvert.ToFSharpFunc(decide)), null, null);
public FSharpAsync <string> FSharpAsyncFailureMethod(string parameter)
{
return(FSharpAsync.AwaitTask(
Task.FromException <string>(new InvalidOperationException("Test exception"))));
}
public FSharpAsync <string> FSharpAsyncMethod(string parameter)
{
return(FSharpAsync.AwaitTask(Task.FromResult(parameter)));
}
public override FSharpAsync <Unit> Invoke(Unit unitVar)
{
_ = builder;
return(FSharpAsync.AwaitTask(_projectorHandler.Project(_stream, span)));
}
public FSharpAsync <AudioPlayer.AudioPlayerInfo> MoveToPreviousTrack(AudioPlayer.AudioPlayerInfo value)
{
System.Windows.MessageBox.Show("MoveToPreviousTrack");
return(FSharpAsync.AwaitTask(Task.FromResult(value)));
}
public static Task <T> ToTask <T>(this FSharpAsync <T> item) =>
FSharpAsync.StartAsTask(
item,
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None
);
private FsharpFolderComposite FindProjectFilesUsingBuildalyzer(IAnalyzerResult analyzerResult)
{
var inputFiles = new FsharpFolderComposite();
var projectUnderTestDir = Path.GetDirectoryName(analyzerResult.ProjectFilePath);
var projectRoot = Path.GetDirectoryName(projectUnderTestDir);
var rootFolderComposite = new FsharpFolderComposite()
{
FullPath = projectRoot,
RelativePath = string.Empty
};
var cache = new Dictionary <string, FsharpFolderComposite> {
[string.Empty] = rootFolderComposite
};
// Save cache in a singleton so we can use it in other parts of the project
FolderCompositeCache <FsharpFolderComposite> .Instance.Cache = cache;
inputFiles.Add(rootFolderComposite);
var fSharpChecker = FSharpChecker.Create(projectCacheSize: null, keepAssemblyContents: null, keepAllBackgroundResolutions: null, legacyReferenceResolver: null, tryGetMetadataSnapshot: null, suggestNamesForErrors: null, keepAllBackgroundSymbolUses: null, enableBackgroundItemKeyStoreAndSemanticClassification: null);
foreach (var sourceFile in analyzerResult.SourceFiles)
{
// Skip xamarin UI generated files
if (sourceFile.EndsWith(".xaml.cs"))
{
continue;
}
var relativePath = Path.GetRelativePath(projectUnderTestDir, sourceFile);
var folderComposite = GetOrBuildFolderComposite(cache, Path.GetDirectoryName(relativePath), projectUnderTestDir, projectRoot, inputFiles);
var fileName = Path.GetFileName(sourceFile);
var file = new FsharpFileLeaf()
{
SourceCode = FileSystem.File.ReadAllText(sourceFile),
RelativePath = FileSystem.Path.Combine(folderComposite.RelativePath, fileName),
FullPath = sourceFile
};
// Get the syntax tree for the source file
Tuple <FSharpProjectOptions, FSharpList <FSharpErrorInfo> > fSharpOptions = FSharpAsync.RunSynchronously(fSharpChecker.GetProjectOptionsFromScript(filename: file.FullPath, sourceText: SourceText.ofString(file.SourceCode), previewEnabled: null, loadedTimeStamp: null, otherFlags: null, useFsiAuxLib: null, useSdkRefs: null, assumeDotNetFramework: null, extraProjectInfo: null, optionsStamp: null, userOpName: null), timeout: null, cancellationToken: null);
FSharpParseFileResults result = FSharpAsync.RunSynchronously(fSharpChecker.ParseFile(fileName, SourceText.ofString(file.SourceCode), fSharpChecker.GetParsingOptionsFromProjectOptions(fSharpOptions.Item1).Item1, userOpName: null), timeout: null, cancellationToken: null);
if (result.ParseTree.Value.IsImplFile)
{
var syntaxTree = (ImplFile)result.ParseTree.Value;
file.SyntaxTree = syntaxTree;
folderComposite.Add(file);
}
else
{
var message = $"Cannot make Fsharp SyntaxTree from .fsi filetype (SyntaxTree.ParsedImplFileInput class wanted)";
throw new InputException(message);
}
}
return(inputFiles);
}
public async Task AsyncGetAwaiterTestAsync()
{
var asy = FSharpAsync.Sleep(500);
await asy;
}
public async Task DoUpdateAsync()
{
if (IsDisposed)
{
return;
}
var buffer = _currentSnapshot;
var path = _document.FilePath;
// replace with user token
var token = _cts.Token;
var instance = await FsLintVsPackage.Instance.WithCancellation(token);
// this acts as a throttle
await Task.Delay(200, token);
if (Project == null)
{
await instance.JoinableTaskFactory.SwitchToMainThreadAsync();
var project = instance.Dte.Solution.FindProjectItem(path)?.ContainingProject;
if (project == null)
{
return;
}
if (instance.SolutionService.GetProjectOfUniqueName(project.UniqueName, out var vsHierarchy) != VSConstants.S_OK)
{
return;
}
if (instance.SolutionService.GetGuidOfProject(vsHierarchy, out var guid) != VSConstants.S_OK)
{
return;
}
Project = new LintProjectInfo(project.Name, guid, vsHierarchy);
}
await Task.Yield();
var connectionString = SqlAnalyzer.tryFindConnectionString(path);
if (string.IsNullOrWhiteSpace(connectionString))
{
return;
}
var source = _currentSnapshot.GetText();
var sourceText = SourceText.ofString(source);
var getProjectOptions = _provider.CheckerInstance.GetProjectOptionsFromScript(
filename: path,
source: sourceText,
assumeDotNetFramework: false,
useSdkRefs: true,
useFsiAuxLib: true,
previewEnabled: true,
otherFlags: new string[] { "--targetprofile:netstandard" },
loadedTimeStamp: FSharpOption <DateTime> .None,
extraProjectInfo: FSharpOption <object> .None,
optionsStamp: FSharpOption <long> .None,
userOpName: FSharpOption <string> .None,
sdkDirOverride: FSharpOption <string> .None
);
var(options, errors) = await FSharpAsync.StartAsTask(getProjectOptions, null, token);
if (errors.Any())
{
return;
}
var performParseAndCheck = _provider.CheckerInstance.ParseAndCheckFileInProject(
filename: path,
fileVersion: 1,
sourceText: sourceText,
options: options,
userOpName: FSharpOption <string> .None
);
var(parseResults, checkAnswer) = await FSharpAsync.StartAsTask(performParseAndCheck, null, token);
if (parseResults.ParseHadErrors || checkAnswer.IsAborted)
{
return;
}
var checkResults = SqlAnalyzer.checkAnswerResult(checkAnswer).Value;
var context = new SqlAnalyzerContext(
fileName: path,
content: source.Split('\n'),
parseTree: parseResults.ParseTree.Value,
symbols: SqlAnalyzer.getSymbols(checkResults)
);
var operationBlocks = SyntacticAnalysis.findSqlOperations(context);
var loadedSchema = SqlAnalysis.databaseSchema(connectionString);
var errorMessages = new List <Message>();
if (loadedSchema.IsError)
{
foreach (var operation in operationBlocks)
{
var containsSkipAnalysis = operation.blocks.Any(block => block.IsSkipAnalysis);
foreach (var block in operation.blocks)
{
var blockRange = block.Range();
if ((block.IsQuery || block.IsTransaction) && OptionModule.IsSome(blockRange) && !containsSkipAnalysis)
{
var internalError = (loadedSchema.ErrorValue ?? "").Replace("3D000:", "").Replace("28P01:", "");
var fullError = $"Error occured while trying to connect to the database using the configured connection string in NPGSQL_FSHARP in order to perform static analysis:{internalError}";
var errorMessage = new Message(
type: "Error",
message: fullError,
code: "SQL101",
severity: Severity.Warning,
range: blockRange.Value,
fixes: Microsoft.FSharp.Collections.FSharpList <Fix> .Empty
);
errorMessages.Add(errorMessage);
}
}
}
}
else
{
var databaseSchema = loadedSchema.ResultValue;
foreach (var operation in operationBlocks)
{
foreach (var analysisOutput in SqlAnalysis.analyzeOperation(operation, connectionString, databaseSchema))
{
errorMessages.Add(analysisOutput);
}
}
}
var oldLintingErrors = this.Factory.CurrentSnapshot;
var newLintErrors = new LintingErrorsSnapshot(_document, oldLintingErrors.VersionNumber + 1);
foreach (var error in errorMessages)
{
var span = RangeToSpan(error.Range, buffer);
newLintErrors.Errors.Add(new LintError(span, error, Project));
}
await instance.JoinableTaskFactory.SwitchToMainThreadAsync();
if (token.IsCancellationRequested)
{
return;
}
UpdateLintingErrors(newLintErrors);
}
public static T RunAsTask <T>([NotNull] this FSharpAsync <T> async, [CanBeNull] Action interruptChecker = null) => Shell.Instance.GetComponent <IShellLocks>().IsWriteAccessAllowed() ? RunTransferringWriteLock(async) : RunInterrupting(async, interruptChecker);
// Project from the synchronized state, without the possibility of adding events that Decide(Func) admits public async Task <T> Query <T>(Func <TState, T> project) => await FSharpAsync.StartAsTask(Query(FuncConvert.FromFunc(project)), null, null);
public static Task <T> ToTask <T>(this FSharpAsync <T> task)
{
return(FSharpAsync.StartAsTask(task, null, null));
}
public static Func <Action <TResult>, Action <Exception>, IBackgroundTask> CreateForAsync <TResult>(FSharpAsync <TResult> async, DeviceDescriptionHolder dev)
{
return((onSuccess, onError) => {
var disp = new MultipleAssignmentDisposable();
var backgroundTask = new AnonymousBackgroundTask();
backgroundTask.name = "Restore device " + dev.Name;
backgroundTask.description = "Address: " + dev.Address;
backgroundTask.state = BackgroundTaskState.InProgress;
backgroundTask.disposable = Disposable.Create(() => {
disp.Dispose();
backgroundTask.state = BackgroundTaskState.Canceled;
});
disp.Disposable = async.Subscribe(
res => {
onSuccess(res);
backgroundTask.state = BackgroundTaskState.Completed;
},
err => {
onError(err);
backgroundTask.state = BackgroundTaskState.Failed;
}
);
return backgroundTask;
});
}
public FSharpAsync <AudioPlayer.AudioPlayerInfo> StartAudioPlayer(AudioPlayer.AudioPlayerInfo value)
{
System.Windows.MessageBox.Show("StartAudioPlayer");
return(FSharpAsync.AwaitTask(Task.FromResult(value)));
}
public async Task AsyncAsTaskTestAsync()
{
var asy = FSharpAsync.Sleep(500);
await asy.AsTask();
}
/// <summary>
/// Recursively scans the given directory for files to mutate
/// </summary>
private FsharpFolderComposite FindInputFiles(string path, string projectUnderTestDir, string parentFolder)
{
var lastPathComponent = Path.GetFileName(path);
var folderComposite = new FsharpFolderComposite
{
FullPath = Path.GetFullPath(path),
RelativePath = Path.Combine(parentFolder, lastPathComponent),
};
foreach (var folder in FileSystem.Directory.EnumerateDirectories(folderComposite.FullPath).Where(x => !_foldersToExclude.Contains(Path.GetFileName(x))))
{
folderComposite.Add(FindInputFiles(folder, projectUnderTestDir, folderComposite.RelativePath));
}
var fSharpChecker = FSharpChecker.Create(projectCacheSize: null, keepAssemblyContents: null, keepAllBackgroundResolutions: null, legacyReferenceResolver: null, tryGetMetadataSnapshot: null, suggestNamesForErrors: null, keepAllBackgroundSymbolUses: null, enableBackgroundItemKeyStoreAndSemanticClassification: null);
foreach (var file in FileSystem.Directory.GetFiles(folderComposite.FullPath, "*.fs", SearchOption.TopDirectoryOnly))
{
var fileName = Path.GetFileName(file);
var fileLeaf = new FsharpFileLeaf()
{
SourceCode = FileSystem.File.ReadAllText(file),
RelativePath = Path.Combine(folderComposite.RelativePath, fileName),
FullPath = file,
};
// Get the syntax tree for the source file
Tuple <FSharpProjectOptions, FSharpList <FSharpErrorInfo> > fsharpoptions = FSharpAsync.RunSynchronously(fSharpChecker.GetProjectOptionsFromScript(fileLeaf.FullPath, SourceText.ofString(fileLeaf.SourceCode), previewEnabled: null, loadedTimeStamp: null, otherFlags: null, useFsiAuxLib: null, useSdkRefs: null, assumeDotNetFramework: null, extraProjectInfo: null, optionsStamp: null, userOpName: null), timeout: null, cancellationToken: null);
FSharpParseFileResults result = FSharpAsync.RunSynchronously(fSharpChecker.ParseFile(fileLeaf.FullPath, SourceText.ofString(fileLeaf.SourceCode), fSharpChecker.GetParsingOptionsFromProjectOptions(fsharpoptions.Item1).Item1, userOpName: null), timeout: null, cancellationToken: null);
if (result.ParseTree.Value.IsImplFile)
{
var syntaxTree = (ImplFile)result.ParseTree.Value;
fileLeaf.SyntaxTree = syntaxTree;
folderComposite.Add(fileLeaf);
}
else
{
var message = $"Cannot make Fsharp SyntaxTree from .fsi filetype (SyntaxTree.ParsedImplFileInput class wanted)";
throw new InputException(message);
}
}
return(folderComposite);
}
public async Task DoUpdateAsync()
{
if (IsDisposed)
{
return;
}
var buffer = _currentSnapshot;
var path = _document.FilePath;
// replace with user token
var token = _cts.Token;
var instance = await FsLintVsPackage.Instance.WithCancellation(token);
// this acts as a throttle
await Task.Delay(200, token);
if (Project == null)
{
await instance.JoinableTaskFactory.SwitchToMainThreadAsync();
var project = instance.Dte.Solution.FindProjectItem(path)?.ContainingProject;
if (project == null)
{
return;
}
if (instance.SolutionService.GetProjectOfUniqueName(project.UniqueName, out var vsHierarchy) != VSConstants.S_OK)
{
return;
}
if (instance.SolutionService.GetGuidOfProject(vsHierarchy, out var guid) != VSConstants.S_OK)
{
return;
}
Project = new LintProjectInfo(project.Name, guid, vsHierarchy);
}
await Task.Yield();
var connectionString = SqlAnalyzer.tryFindConnectionString(path);
if (string.IsNullOrWhiteSpace(connectionString))
{
return;
}
var loadedSchema = SqlAnalysis.databaseSchema(connectionString);
if (loadedSchema.IsError)
{
return;
}
var source = _currentSnapshot.GetText();
var sourceText = SourceText.ofString(source);
var getProjectOptions = _provider.CheckerInstance.GetProjectOptionsFromScript(
filename: path,
sourceText: sourceText,
assumeDotNetFramework: false,
useSdkRefs: true,
useFsiAuxLib: true,
previewEnabled: true,
otherFlags: new string[] { "--targetprofile:netstandard" },
loadedTimeStamp: FSharpOption <DateTime> .None,
extraProjectInfo: FSharpOption <object> .None,
optionsStamp: FSharpOption <long> .None,
userOpName: FSharpOption <string> .None
);
var(options, errors) = await FSharpAsync.StartAsTask(getProjectOptions, null, token);
if (errors.Any())
{
return;
}
var performParseAndCheck = _provider.CheckerInstance.ParseAndCheckFileInProject(
filename: path,
fileversion: 1,
sourceText: sourceText,
options: options,
textSnapshotInfo: FSharpOption <object> .None,
userOpName: FSharpOption <string> .None
);
var(parseResults, checkAnswer) = await FSharpAsync.StartAsTask(performParseAndCheck, null, token);
if (parseResults.ParseHadErrors || checkAnswer.IsAborted)
{
return;
}
var checkResults = SqlAnalyzer.checkAnswerResult(checkAnswer).Value;
var context = new SqlAnalyzerContext(
fileName: path,
content: source.Split('\n'),
parseTree: parseResults.ParseTree.Value,
symbols: SqlAnalyzer.getSymbols(checkResults)
);
var databaseSchema = loadedSchema.ResultValue;
var errorMessages =
from operation in SyntacticAnalysis.findSqlOperations(context)
from analysisOutput in SqlAnalysis.analyzeOperation(operation, connectionString, databaseSchema)
select analysisOutput;
var oldLintingErrors = this.Factory.CurrentSnapshot;
var newLintErrors = new LintingErrorsSnapshot(_document, oldLintingErrors.VersionNumber + 1);
foreach (var error in errorMessages)
{
var span = RangeToSpan(error.Range, buffer);
newLintErrors.Errors.Add(new LintError(span, error, Project));
}
await instance.JoinableTaskFactory.SwitchToMainThreadAsync();
if (token.IsCancellationRequested)
{
return;
}
UpdateLintingErrors(newLintErrors);
}
/// <summary>
/// Implementation of the world of effectful computations. It respects the threading model of WPF.
/// </summary>
/// <param name="effect">
/// The effectful computation to be performed.
/// </param>
/// <param name="messageDestination">
/// A function which accepts the message produced by <paramref name="effect"/>, when it completes.
/// </param>
private static async void ExecuteEffect(FSharpAsync<Message> effect, Action<Message> messageDestination)
{
var m = await FSharpAsync.StartAsTask(
effect,
FSharpOption<TaskCreationOptions>.None,
FSharpOption<CancellationToken>.None);
messageDestination(m);
}
