Merge main to features/value_tracking #52902

… access to the default capabilities

…amed. Fixes an issue with generated TS documents without an undo history throwing during rename

…ktop-binary' into vscode_lsp

…cClassificationTaggerProvider.TagComputer.cs

This optimizes the case where a project doesn't have any generators; prior to this change we'd still produce a compilation to pass to the generator driver, even though that was entirely unnecessary.

…Projects

Ignore razor virtual buffers as they cannot be ren…

Pass severity to DiagnosticHelper.Create

…ped.

Use `Environment.FailFast` so we trigger a crash when an assertion fails in the bootstrap phase. The rest of our setup for the build correctness legs should ensure this results in a captured heap dump

…ad-error Fix editorconfig UI package load error

Simplify syntactic classification

…ion2

Do not mark our navto pattern match items as having punctuation stripped

Remove unnecessary initial notification code in the tagger

…ion2

Remove use of lists in the syntactic classifier

…under the caret.

Cleanup connect/disconnect in the tagger

Remove dead code from the tagger.

Fix issue with highlight refs where we might highlight something not under the caret.

Simplify async tagger delays.

Previously, a new ResultId was generated for each semantic tokens edit request (called every ~0.5s) regardless of whether the doc's content changed. We switch to re-using the old ResultId instead, which will avoid us inserting into the cache unnecessarily.

Remove the complex IAccurateTagger codepaths from the generic async tagger implementation.

Move code from Tagger to TagSource.

This reverts commit c31d8af.

…-d797-4a78-b7dc-0d22ffe76347 Revert "[main] Update dependencies from dotnet/arcade"

Devirtualization of EqualityComparer<T> is not supported on .NET Framework, and the IsValueType check is also not an intrinsic. This change improves analyzer driver performance by 6% on .NET Framework.

Do not fire TagsChanged for the copy/paste classifier.

Fixes #52624.

Remove usages of ForegroundNotificationService in favor of JTF.

Avoid attempted equality comparer devirtualization on .NET Framework

Switch to a lock to protect state, instead of going back to UI thread.

…ider.TagSource_ProduceTags.cs

Fix GetModifiers and WithModifiers to handle local functions

Fixes #52761

Increase compiler server request size limit to 5MB

…nfoBarService.cs Co-authored-by: David Barbet <dibarbet@gmail.com>

Few fixes for DeclarationKind enum

Add LogLevel to LogMessage

Refactor InProcLanguageServer to expose an API for extension

Simplify threading model implementation in the async tagger.

Change functionid value in main as it conflicts with dev17

Only show an OOP error message once per feature area per session

Move all threading movement in the tagger to a single method.

Add FindUsages external access layer for typescript.

Introduce EA pattern for TypeScript for navbars.

Get .NET SDK to restore internal tools

Remove unexecuted VB assemblies from OptProf test mapping

* Add AssertOrFailFast This introduces `AssertOrFailFast`. This is like `Debug.Assert` but it will provide a crash dump when the `Assert` fails in CI runs.

* Fix exception logic in MSBuild The unexpected exception logic uses resources to add localized messages to the MSBuild log. Turns out our tasks were not properly hooking up resources into the log. That means when unexpected exceptions happen the information for them was completely lost because logging through an `InvalidOperationException` which wasn't handled. Fix the resources to be properly initialized and added a few tests to enforce it. closes #52467

Apply AdditionalDocument changes in MSBuildWorkspace

The CompilationTracker, even if we were reusing existing trees from a prior run, would always take the Compilation that didn't have the generated syntax trees and would add the generated trees to produce the final compilation. This change tries to make it smarter, so if the generated trees are identical, we instead take the prior compilation with generated trees and instead update that with the updates to non-generated trees. This can help us avoid having to recompute the declaration tables for the generated trees (which can often be large) multiple times.

Read ProjectReferences with their Path as the ItemSpecification

…space-performance Improve performance in various parts of the Workspace's handling around source generators

…d files

Now that the compiler doesn't actually parse generated files eagerly, we can use the same parsing mechanism we do for parsing regular trees. This removes some duplication and also will set us up to have forked solutions where we have generated trees that didn't come from the compiler at all.

We pass these around as a group on a fairly regular basis, so let's just make them a single type.

…ontainers

This is just the invocation of the extract interface refactoring and then some immediate follow-ups to trivially retarget types.

…documents The overall approach here is to make GetOpenDocumentInCurrentContextWithChanges work to return SourceGeneratedDocuments like anything else. The strange bit is we have to ensure the source generated document matches the text that's currently in the buffer. Consider a case where: 1. The user makes a change in another file which means the generator will produce new results. That generator is running async. 2. The user switches back to the generated file and immediately invokes a command on it before we refresh the buffer contents. In that case, the buffer contents are stale, but we need to ensure the SourceGeneratedDocument given to all our features is in sync with the actual text buffer, or otherwise spans and everything won't align. This is very similar to the general concept of the "with changes" portion of that API: you may always get a forked version of the world that doesn't represent an entirely consistent view of the entire world, but it's at least going to ensure your document matches your starting point. In the "regular case" that the generator has already ran and we're able to confirm the contents of the text buffer still matches the generated output, this (like for regular documents) doesn't fork anything at all -- you end up with the Solution object that matches Workspace.CurrentSolution. The implementation approach here is to ensure that when we do fork a snapshot the final Compilation has the tree matching the text present no matter what. One approach would have been to fork the compilation tracker with some extra special state that remembers to fix that up in the end but I had two concerns with that approach: 1. The compilation tracker implementation is already crazy complicated. 2. Forking the compilation tracker while a generator is running potentially now running generators twice depending on the timing. I decided to take the approach that CompilationTracker has an interface extracted for it's actual surface area, and then when we do the forked solution we create a different implementation of that interface that forwards to the underlying implementation and then replaces out the tree at the very end. This means we don't ever have generators running twice, and the magic of swapping out the tree is all contained in the special implementation and the core implementation is untouched.

…uleOrDynamic works This is a naive implementation that simply ensures we don't get different behavior from the main implementation. Most of this change is just moving the creation and matching logic into UnrootedSymbolSet.cs itself.

This works the same as the GetOpenDocumentInCurrentContextWithChanges. This fixes navigation bars specifically which use this.

We were holding onto the ISourceGenerator instance and passing it around for various reasons; this decomposes it into holding onto the assembly name and type name strings, so we can serialize this across processes.

We don't know up-front whether a generated file exists in the workspace, and our APIs to grab a document from a buffer are intended to complete quickly. If it turns out later the file isn't in the workspace anymore we will fake it and add it back so that way features aren't surprised by this. However, that means semantics in that file may be inaccurate. Disconnecting the document means that once the file is gone, then we won't be in this incorrect state for long.

It's a checksum of the attributes, not info, which can be confusing here.

This isn't actually used by anything.

We already had an assert that we shouldn't read one, but this adds the same assert on the sending side where it's easier to debug the source of the problem.

There are a number of asserts which try to ensure that we don't try to sync a null across the wire during solution sync. If you wanted to try using Checksum.Null as a placeholder for an optional value during synchronization, you'd hit these asserts because not everything would filter them out. This change filters them out during some parts of the synchronization process, allowing it to be used as an optional value.

The solution has the concept of "frozen" source generated documents where we force a solution snapshot to have a source generated document of a certain content, even if the generator is producing something new. This allows us to isolate features operating on a source generated document open in the editor that hasn't been updated yet -- we freeze the contents of the source generated file to match the open buffer, so taggers and the like can still function normally. This commit ensures that we synchronize those to the OOP process so everything stays in sync. The primary counter-intuitive bit is why we're holding onto this information at the SolutionState level, but that's because the place where the information is ultimately needed is the compilation trackers, which are held by the Solution object and nowhere else. This allows us to reuse the underlying project states for maximum efficiency.

Since we want to put this into 16.10 but we're past the feature cutoff, we'll put this behind an experimental flag.

…nerated-files-to-the-workspace Connect open source generated files to the workspace

Commits on Apr 3, 2021

Update SyntaxNodeExtensions.cs

Youssef1313 authored Apr 3, 2021

Configuration menu

View commit details

Copy full SHA for 765c5ad

Browse repository at this point

Copy the full SHA

765c5ad View commit details

Browse the repository at this point in the history

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Merge main to features/value_tracking #52902

Merge main to features/value_tracking #52902

Commits on Apr 1, 2021

Commits on Apr 3, 2021

Commits on Apr 8, 2021

Commits on Apr 9, 2021

Commits on Apr 13, 2021

Commits on Apr 14, 2021

Commits on Apr 15, 2021

Commits on Apr 16, 2021

Commits on Apr 19, 2021

Commits on Apr 20, 2021

Commits on Apr 21, 2021

Commits on Apr 22, 2021

Commits on Apr 23, 2021

Commits on Apr 24, 2021