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 with `?` outside a `#nullable` context.
 
 In metadata, nullable reference types are annotated with a `[Nullable]` attribute.
 ```c#
@@ -22,54 +22,46 @@ 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.
+All value types are marked with flag 0 (oblivious).
+
+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 are 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?[]!
+int Int; // int
+Nullable<int> NullableInt1; // Nullable<int>
 ```
-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>
@@ -5629,9 +5626,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>