Adjust the way nullable annotations are represented in metadata

docs/features/nullable-reference-types.md

@@ -8,7 +8,7 @@ In source, nullable reference types are annotated with `?`.
 string? OptString; // may be null
 Dictionary<string, object?>? OptDictionaryOptValues; // dictionary may be null, values may be null
 ```
-A warning is reported when annotating a reference type or unconstrained generic type with `?` outside a `NonNullTypes(true)` context.
+A warning is reported when annotating a reference type or unconstrained generic type with `?` outside a `#nullable` context.
 
 In metadata, nullable reference types are annotated with a `[Nullable]` attribute.
 ```c#
@@ -22,54 +22,43 @@ namespace System.Runtime.CompilerServices
  AllowMultiple = false)]
  public sealed class NullableAttribute : Attribute
  {
- public NullableAttribute() { }
- public NullableAttribute(bool[] b) { }
+ public NullableAttribute(byte b) { }
+ public NullableAttribute(byte[] b) { }
  }
 }
 ```
-The parameter-less constructor is emitted for simple type references with top-level nullability and for type parameter definitions that have a `class?` constraint;
-the constructor with `bool[]` parameter is emitted for type references with nested types and nullability.
+
+Each type reference is accompanied by a NullableAttribute with an array of bytes, where 0 is Oblivious, 1 is NotAnnotated and 2 is Annotated. 
+
+To optimize trivial cases the attribute can be omitted, or instead can be replaced with an attribute that takes a single byte value rather than an array. 
+
+Trivial/optimized cases:
+1) All parts are NotAnnotated � a NullableAttribute with a single value 1 (rather than an array of 1s)
+2) All parts are Annotated - a NullableAttribute with a single value 2 (rather than an array of 2s)
+3) All parts are Oblivious � the attribute is omitted, this matches how we interpret the lack of an attribute in legacy assemblies.
+ For completeness, we would also recognize a NullableAttribute with a single value 0 (rather than an array of 0s),
+ but compiler will never emit an attribute like this. 
+
+NullableAttribute(1) should be placed on a type parameter definition that has a `class!` constraint.
+NullableAttribute(2) should be placed on a type parameter definition that has a `class?` constraint.
+Other forms of NullableAttribute ar not emitted on type parameter definitions and are not specially recognized on them.
+
+The `NullableAttribute` type declaration is synthesized by the compiler if it is not included in the compilation, but is needed to produce the output.
+
 ```c#
 // C# representation of metadata
-[Nullable]
+[Nullable(2)]
 string OptString; // string?
-[Nullable(new[] { true, false, true })]
+[Nullable(new[] { 2, 1, 2 })]
 Dictionary<string, object> OptDictionaryOptValues; // Dictionary<string!, object?>?
+string[] Oblivious1; // string~[]~
+[Nullable(0)] string[] Oblivious2; // string~[]~
+[Nullable(new[] { 0, 0 })] string[] Oblivious3; // string~[]~
+[Nullable(1)] string[] NotNull1; // string![]!
+[Nullable(new[] { 1, 1 })] string[] NotNull2; // string![]!
+[Nullable(new[] { 0, 2 })] string[] ObliviousMaybeNull; // string?[]~
+[Nullable(new[] { 1, 2 })] string[] NotNullMaybeNull; // string?[]!
 ```
-The `NullableAttribute` type declaration is synthesized by the compiler if it is not included in the compilation.
-
-Unannotated reference types are non-nullable or null-oblivious depending on whether the containing scope includes `[NonNullTypes]`.
-```c#
-namespace System.Runtime.CompilerServices
-{
- [AttributeUsage(AttributeTargets.Class |
- AttributeTargets.Constructor |
- AttributeTargets.Delegate |
- AttributeTargets.Enum |
- AttributeTargets.Event |
- AttributeTargets.Field |
- AttributeTargets.Interface |
- AttributeTargets.Method |
- AttributeTargets.Module |
- AttributeTargets.Property |
- AttributeTargets.Struct,
- AllowMultiple = false)]
- internal sealed class NonNullTypesAttribute : Attribute
- {
- public NonNullTypesAttribute(bool enabled = true) { }
- }
-}
-```
-If there is no `[NonNullTypes]` attribute at any containing scope, including the module, reference types are null-oblivious.
-```c#
-[NonNullTypes(false)] string[] Oblivious; // string~[]~
-[NonNullTypes(true)] string[] NotNull; // string![]!
-[NonNullTypes(false), Nullable(new[] { false, true })] string[] ObliviousMaybeNull; // string?[]~
-[NonNullTypes(true), Nullable(new[] { false, true })] string[] NotNullMaybeNull; // string?[]!
-```
-The `NonNullTypesAttribute` is always implicitly included in a compilation, but is only emitted if it is referenced in source. It cannot be referenced from metadata (assembly or module).
-`NonNullTypesAttribute` can only be used in C# 8.0 compilations (or above).
-
 ## Declaration warnings
 _Describe warnings reported for declarations in initial binding._
 

src/Compilers/CSharp/Portable/Binder/Binder.cs

@@ -216,7 +216,7 @@ internal virtual Symbol ContainingMemberOrLambda
  /// <summary>
  /// Are we in a context where un-annotated types should be interpreted as non-null?
  /// </summary>
- internal Symbol NonNullTypesContext => ContainingMember().OriginalDefinition;
+ internal INonNullTypesContext NonNullTypesContext => (Flags & BinderFlags.InEEMethodBinder) == 0 ? ContainingMember().OriginalDefinition : NonNullTypesTrueContext.Instance;
 
  /// <summary>
  /// Is the contained code within a member method body?

src/Compilers/CSharp/Portable/Binder/BinderFlags.cs

@@ -103,6 +103,11 @@ internal enum BinderFlags : uint
  /// </summary>
  InContextualAttributeBinder = 1 << 29,
 
+ /// <summary>
+ /// Are we binding for the purpose of an Expression Evaluator
+ /// </summary>
+ InEEMethodBinder = 1 << 30,
+
  // Groups
 
  AllClearedAtExecutableCodeBoundary = InLockBody | InCatchBlock | InCatchFilter | InFinallyBlock | InTryBlockOfTryCatch | InNestedFinallyBlock,

src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs

@@ -1494,28 +1494,22 @@ internal Symbol ResultSymbol(
  var srcSymbol = symbols[best.Index];
  var mdSymbol = symbols[secondBest.Index];
 
+ object arg0;
+
+ if (best.IsFromSourceModule)
+ {
+ arg0 = srcSymbol.Locations.First().SourceTree.FilePath;
+ }
+ else
+ {
+ Debug.Assert(best.IsFromAddedModule);
+ arg0 = srcSymbol.ContainingModule;
+ }
+
  //if names match, arities match, and containing symbols match (recursively), ...
  if (srcSymbol.ToDisplayString(SymbolDisplayFormat.QualifiedNameArityFormat) ==
  mdSymbol.ToDisplayString(SymbolDisplayFormat.QualifiedNameArityFormat))
  {
- if (srcSymbol.Equals(Compilation.GetWellKnownType(WellKnownType.System_Runtime_CompilerServices_NonNullTypesAttribute)))
- {
- // Silently prefer the injected symbol
- return originalSymbols[best.Index];
- }
-
- object arg0;
- if (best.IsFromSourceModule)
- {
- SyntaxTree tree = srcSymbol.Locations.FirstOrNone().SourceTree;
- arg0 = tree != null ? (object)tree.FilePath : MessageID.IDS_InjectedDeclaration.Localize();
- }
- else
- {
- Debug.Assert(best.IsFromAddedModule);
- arg0 = srcSymbol.ContainingModule;
- }
-
  if (srcSymbol.Kind == SymbolKind.Namespace && mdSymbol.Kind == SymbolKind.NamedType)
  {
  // ErrorCode.WRN_SameFullNameThisNsAgg: The namespace '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the namespace defined in '{0}'.

src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs

@@ -499,7 +499,7 @@ private BoundLambda ReallyBind(NamedTypeSymbol delegateType)
 
  if (!returnType.IsNull)
  {
- if (returnType.ContainsNullableReferenceTypes())
+ if (returnType.NeedsNullableAttribute())
  {
  binder.Compilation.EnsureNullableAttributeExists(diagnostics, lambdaSymbol.DiagnosticLocation, modifyCompilation: false);
  // Note: we don't need to warn on annotations used without NonNullTypes context for lambdas, as this is handled in binding already

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -4284,9 +4284,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
  <data name="IDS_Text" xml:space="preserve">
  <value>&lt;text&gt;</value>
  </data>
- <data name="IDS_InjectedDeclaration" xml:space="preserve">
- <value>injected declaration</value>
- </data>
  <data name="IDS_FeatureNullPropagatingOperator" xml:space="preserve">
  <value>null propagating operator</value>
  </data>
@@ -5628,9 +5625,6 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
  <data name="ERR_BadDynamicAwaitForEach" xml:space="preserve">
  <value>Cannot use a collection of dynamic type in an asynchronous foreach</value>
  </data>
- <data name="ERR_ExplicitNonNullTypesAttribute" xml:space="preserve">
- <value>Explicit application of 'System.Runtime.CompilerServices.NonNullTypesAttribute' is not allowed.</value>
- </data>
  <data name="ERR_NullableDirectiveQualifierExpected" xml:space="preserve">
  <value>Expected enable or disable</value>
  </data>