Merge main into feature/value_tracking

…king/ui

Add value tracking service

…feature/value_tracking/ui

Add UI for Value Tracking

Merge 'main' into 'features/StaticAbstractMembersInInterfaces'

Co-authored-by: David Wengier <david.wengier@microsoft.com>

…ps://github.com/ryzngard/roslyn into feature/value_tracking/handle_single_expression

…_single_expression

Handle expressions and method calls

…events in interfaces. (#52228)

Spec: https://github.com/dotnet/csharplang/blob/9a0dddbf0643993db0da8f48436f2aac60bc20b1/proposals/statics-in-interfaces.md

Related to #52202.

Relevant quotes from the spec:

#### Abstract virtual members
Static interface members other than fields are allowed to also have the `abstract` modifier. Abstract static members are not allowed to have a body (or in the case of properties, the accessors are not allowed to have a body). 

``` c#
interface I<T> where T : I<T>
{
    static abstract void M();
    static abstract T P { get; set; }
    static abstract event Action E;
    static abstract T operator +(T l, T r);
}
```

#### Explicitly non-virtual static members
For symmetry with non-virtual instance members, static members should be allowed an optional `sealed` modifier, even though they are non-virtual by default:

``` c#
interface I0
{
    static sealed void M() => Console.WriteLine("Default behavior");
    
    static sealed int f = 0;
    
    static sealed int P1 { get; set; }
    static sealed int P2 { get => f; set => f = value; }
    
    static sealed event Action E1;
    static sealed event Action E2 { add => E1 += value; remove => E1 -= value; }
    
    static sealed I0 operator +(I0 l, I0 r) => l;
}
```

…feature. (#52366)

Spec: https://github.com/dotnet/csharplang/blob/3e6e0d77504b6d05eaec4232303d58b1fd806b51/proposals/statics-in-interfaces.md

- Added tests to verify metadata produced for abstract static memebers in interfaces.
- Added a temporary stub for the runtime support check.
- Adjusted variance safety checks for signatures of abstract static members.
- Adjusted generic constraints checks to disallow interfaces as type arguments for type parameters that are constrained to an interface with static abstract members.
- Relaxed signature requirements for abstract user-defined operators.

Relevant quotes from the spec:

## Operator restrictions

Today all unary and binary operator declarations have some requirement involving at least one of their operands to be of type `T` or `T?`, where `T` is the instance type of the enclosing type.

These requirements need to be relaxed so that a restricted operand is allowed to be of a type parameter that is constrained to `T`.

## Interface constraints with static abstract members

Today, when an interface `I` is used as a generic constraint, any type `T` with an implicit reference or boxing conversion to `I` is considered to satisfy that constraint.

When `I` has static abstract members this needs to be further restricted so that `T` cannot itself be an interface.

## Variance safety
https://github.com/dotnet/csharplang/blob/main/spec/interfaces.md#variance-safety

Variance safety rules should apply to signatures of static abstract members. The addition proposed in
https://github.com/dotnet/csharplang/blob/main/proposals/variance-safety-for-static-interface-members.md#variance-safety
should be adjusted from

*These restrictions do not apply to occurrences of types within declarations of static members.*

to

*These restrictions do not apply to occurrences of types within declarations of **non-virtual, non-abstract** static members.*

* Adjust an error message

…yle visit of children

…sions_2

Fix handling of out/ref params
Split into a visitor pattern for operations
add more tests

…_improvements

Merge main into features/value_tracking

…_improvements

…ub.com/ryzngard/roslyn into feature/value_tracking/ui_improvements

Co-authored-by: Joey Robichaud <jorobich@microsoft.com>

…ndler.cs

Co-authored-by: CyrusNajmabadi <cyrus.najmabadi@gmail.com>

…racking

Merge main to features/value_tracking

This reverts commit b72d137.

…rovements

Add some UI improvements to Value Tracking. 

* Fix if tool window is open
* Navigate to source on selection
* Add details pane for file information
* Highlight the symbol being followed

…arameters. (#52605)

…faces_05

Merge 'dotnet/main' into `StaticAbstractMembersInInterfaces`

…act static members. (#52659)

…ures/value_tracking

…act method. (#52685)

…racking

Merge main to features/value_tracking

…racking

Merge main to features/value_tracking

…in classes and structures (#52969)

In metadata an implementation should be a static, not newslot, not final, not virtual, not abstract method. Type should have a MethodImpl entry pointing to the ”body” method with a MethodDef index. The “body” must be a method declared within the type. There is no concept of an implicit interface implementation for static methods in metadata. I.e., if there is no corresponding MethodImpl entry, the method isn’t an implementation from runtime point of view.

Language supports both implicit and explicit interface implementation.

Relevant ECMA-335 changes PR - dotnet/runtime#49558

…ourceUserDefinedOperatorSymbolBase to prepare for explicit implementations of operators (#53058)

Shared code is pulled from derived types to the new base. This is just a refactoring, no behavior changes intended.

However, there is a change in behavior that addresses #53069.

Track variable declarations as well as assignments

…racking

Merge main to features/value_tracking

…features/value_tracking_telemetry

…in operators. (#53142)

Also adding a bunch of parsing tests for scenarios without modifiers.

Adds "vs/ide/vbcs/ValueTracking/TrackValueSource" and "vs/ide/vbcs/ValueTracking/Command" as block tracked telemetry for when the command is invoked and when an item is tracked (initial invocation or expansion)

…s in classes and structures (#53130)

This includes support for implicit and explicit implementations.

…features/value_tracking_progress_ui