…e same event id

The `ISyntaxReceiver` is a syntax model that is more IDE friendly than
the pull model that was previously implemented. This allows the IDE to
push data to the generator as it is processing it. This is important
because the IDE is constantly "abandoning" analysis as the customer
types in the IDE which invalidates state and they quickly want to move
to calculating the new state

…nterface type

…plates

- Use the logger factory and console logger in the sample
- Support overriding the event name via the logger message attribute
- Added ToString override
- Enable dumping generated code in the sample for easy debugging

- GetEnumerator is now implemented by calling the indexer to avoid
some redundant code.

- Logging methods without arguments now share a common log state
struct, which eliminates redundant code to JIT.

- Add error checking to ensure the first argument to a logging method
implements the ILogger interface.

- Can now specify logging methods with generic
ILogger<T> as logger.

- Add error checking to prevent generic logging method parameters.

- Add error checking to ensure logging methods are static and partial

- Can now specify logging methods which different access modifiers.

- Eliminate or reduce cascading errors in many cases.

- Ensure generated symbol names all start with __ so as not to conflict
with user-specified symbols

…ions

…messages

…hod in a non-partial class

…methods

- The analyzer flags use of legacy logging methods. The matching fixer
hasn't been implemented yet, but it'll make it easy to convert a legacy
logging method call into a new strongly-typed logger call instead.

- Add support for convert logging method parameters to pascal case.

- Build a testing infra to make it possible to test the fixer.

- Updating dependencies across projects

- The analyzer now highlights Log() methods and the fixer can
deal with those too.

…tion logic

- The code generator reports a few more errors.

- Substantially improve the little Roslyn testing framework ignored
created for this.

- A few analysis-driven improvements.

- Added support for dynamic log levels. Rather than putting the
log level in the [LoggerMessage] attribute, you can put it as
an argument to the logging method. This allows dynamic log levels.

- Made the LogStateHolder types classes instead of structs. This
dedicates one allocation in order to save multiple boxings of the
struct within the ILogger implementation. In addition, the generated
code ends up faster because it doesn't have to copy around a potentially
large struct.

- Fix logic that was parsing the [LoggerMessage] attribute values. it
wasn't dealing with using name: syntax to initialize the values of an
attribute.

- The ILogger parameter to logging methods no longer needs to be the
first argument in the logging method. As long as it is one of the
arguments, everything will work.

- Support specifying the [LoggerMessage] attribute without an actual
message string. When this happens, an auto-generated message string
is produced which outputs the logging method parameters in JSON
format.

- Fixed bug where the LogStateHolder object was being populated with
exception and log level objects when those should have been stripped
away

- Specifying an argument to a logging method, but not supplying a
template for it in the log message is now treated as a warning instead
of an error.

- Add support for the EmitDefaultMessages generator option which
controls whether default messages are produced if the user doesn't
supply one.

- Add support for the FieldName generator option which determines
the name of the field used to retrieve the logger instance when
using instance mode logging methods.

- Add support for the {OriginalFormat} element when enumerating the
TState. This is for compatibility with the existing LoggerMessage.Define
method.

- Add support for automatically expanding IEnumerable logging method
parameters to comma-separated strings. This is for compatibility
with the LoggerMessage.Define method.

- For instance-mode logging method, the code now binds to any single
field that implements ILogger. The code generates an error if there
are multiple matching fields. The code doesn't currently look up the
inheritance hierarchy for fields or properties that match, it certainly
could in the future if that is deemed useful.

- Remove the global option to control the field name used for instance
methods, since the field is now determined dynamically based on type.

- Made a few diagnostics into warnings since they were really just
advisory in nature.

- Cleaned up the diagnostic and resource string names for better
consistency.

- Use LoggerMessage.Define as the implementation mechanism in the common
case. This eliminates the need to introduce public LogValues types.

- When LoggerMessage.Define is not sufficient, the code generator now
emits custom structs to accommodate features that LoggerMessage.Define
doesn't support.

* Remove the code that was warning for the use of DateTime as a parameter.

* Fix bug where the code wasn't handling repeating the ssme template multiple times since switching to the new code gen model.

* Fix bug where the code wasn't handling out of order templates relative
to the logging parameters. This also broke when updating the code gen
model.

* Remove support for optional message strings, and the JSON encoding that
was used in that case.

* Make it so specifying a logger template is now a warning instead of
an error.

* Add three disabled tests (search for TODO) which identify more
error cases the parser should report. These checks should be
implemented soon.

* Remove support for optionally pascal casing arguments. Instead,
the exact casing used in the TState's IReadOnlyList is now derived from the
template.

* Templatet-to-parameter matching is now case-insensitive.

* Remove support for global options since there was nothing left to control.

Two nit fixes

* API Review feedback: LoggerMessageAttribute
* switch event id default to -1
* Update docs regarding message not provided
TODO
- [ ] disable accepting empty message feature if needed

…rator into logging-gen-p4

- Fix build on csproj
- Make InternalsVisibleTo in test for DiagDescriptors asserts
- Fix name typos in sln and cs file

- Fix path separator used for test file location

- Add attribute at the type level.

- Correct namespaces

- Remove "_ = " from test project
- Remove suppressed warnings in RoslynTestUtils
- Use explicit types (not var) in RoslynTestUtils
- GetAssembly -> typeof(..).Assembly
- Use a globbing pattern to copy TestClasses to output
- Remove TreatWarningAsError, on by default
- Correct expected assertions for MessageTest

- Remove InternalsVisibleTo on M.E.DependencyModel.Tests
- Undo add ReferenceOutputAssembly on Logging Generator
- Diff in ParserTests: use explicit type (not var), rename some vars
- Diff in LoggerMessageGeneratorX files: use explicit type (not var)

- Remove from gen csproj: RestoreAdditionalProjectSources
- Remove unused `LoggerField = "_logger";` instantiation

- Dont need Microsoft.CodeAnalysis.Analyzers for gen csproj
- Dont need InternalsVisibleTo for gen in test csproj
- Remove many unnecessary p2p refs in test csproj
- Remove FixIncrementalCoreCompileWithAnalyzers target

- Change SYSLIBXXXX IDs to unique for analyzers
- Move MicrosoftCodeAnalysisCSharpWorkspacesVersion in versions.props
- Set generator test as ProjectExclusions when TargetsMono is true
- Remove AssemblyInfo.cs not needed

- "_ = sb" -> "sb" in Emitter.cs
- Remove dead code in test csproj
- Add MicrosoftCodeAnalysisVersion to versions.props