The syntax node scope should be the innermost node, otherwise
GetSymbolInfo will often return null. As an example, GetSymbolInfo will
return null for an ArgumentSyntax node, but the underlying expression
will likely resolve into a symbol.

Also adds proper null checks in case any of the providers return null.

…rks itself (#2904)

The lambda calls a generic method which has annotation on the generic argument to keep `All`, and the lambda passes its own parent type as the argument. So the annotation will end up marking the lambda itself.

This is a test for #2903

* Created first draft of unused suppressions detection doc.

* design doc improvements

* Fix redundant suppressions design doc wording

* Fix typos

Co-authored-by: Eric Erhardt <[email protected]>

* Apply suggestions from code review

Co-authored-by: Sven Boemer <[email protected]>

* Changed example and added review suggestions.

* Apply suggestions from code review

Co-authored-by: Vitek Karas <[email protected]>

* removed implementation details

Co-authored-by: Eric Erhardt <[email protected]>
Co-authored-by: Sven Boemer <[email protected]>
Co-authored-by: Vitek Karas <[email protected]>

This fixes endless recursion introduced by the change which scans
compiler-generated methods as a group.

This change fixes the re-entrancy instead of putting a temporary value
in the cache, because this will make it easier to fix the behavior of
CheckRequiresReflectionMethodBodyScanner to not consider type
parameter annotations.

This avoids unnecessarily running the reflection methodbody scanner in
the linker, and the dataflow analysis in the analyzer, for methods
that were previously only triggering dataflow analysis due to
annotated generic parameters.

This eliminates unnecessary warnings for reflection access to
compiler-generated code.

* Create infrastructure for CodeFixers that will generate attribute flags for DynamicallyAccessedMembers (DAM) trimmer warnings. This commit includes fixers for the warnings `DynamicallyAccessedMembersMismatchParameterTargetsThisParameter` and `DynamicallyAccessedMembersMismatchFieldTargetsThisParameter`. Additional DiagnosticIds will be supported by future commits.

* Create new class for the DAM CodeFixer that does not rely on base class. The DAM warnings require different attribute placement depending on the type of warning that is raised, causing it to differ from the implementation of the base class.

* Added a test file specifically for the DAM CodeFixer, include tests for the functional fixes as well as tests for fixes that will soon be implemented.

* Converted all test cases within DAM to use string literals

Co-authored-by: Andy Gocke <[email protected]>

…0724.4 (#2913)

[main] Update dependencies from dotnet/runtime

This discovers type parameter mappings between generic type
parameters and static closures which reference them. It detects
the closure environment by scanning for stsfld instructions which
reference generic closure types. There may be multiple methods
associated with the same static closure, so this case doesn't
produce warnings.

This also fixes an unrelated issue where in Release mode, the
compiler can generate struct closure environments that will never
get instantiated via a ctor call. A new testcase runs the
CompilerGeneratedTypes tests in Release mode to cover this.

Makes it so user does not have to zip their dumped dependencies file before running the analyzer and updates documentation to reflect the change.

Add tests for some edge cases due to the analyzer not treating
captured parameters as hoisted variables like the linker does.

Currently the analyzer doesn't detect hoisted parameters, and it
will treat them like normal parameters - warning if a parameter
is assigned a value with an annotation that doesn't match the
parameter annotation. The linker will treat captured parameters
the same as other captured variables, tracking all values that
get assigned. So there is a subtle difference in the warning
behavior:

- Linker won't warn on assignment to annotated captured
  parameter, but analyzer will.

- Linker will produce dataflow warnings for all values assigned
  to a captured parameter, but analyzer will not.