Pack bits in SourceOrdinaryMethodSymbol into an existing bitflag structure we have for all source methods

src/Compilers/CSharp/Portable/Lowering/ClosureConversion/SynthesizedClosureMethod.cs

@@ -218,7 +218,6 @@ protected override ImmutableArray<TypeSymbol> ExtraSynthesizedRefParameters
 
         internal override bool InheritsBaseMethodAttributes => true;
         internal override bool GenerateDebugInfo => !this.IsAsync;
-        internal override bool IsExpressionBodied => false;
 
         internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)
         {

src/Compilers/CSharp/Portable/Lowering/SynthesizedMethodBaseSymbol.cs

@@ -50,7 +50,8 @@ protected SynthesizedMethodBaseSymbol(NamedTypeSymbol containingType,
                 returnsVoid: baseMethod.ReturnsVoid,
                 isExtensionMethod: false,
                 isNullableAnalysisEnabled: false,
-                isMetadataVirtualIgnoringModifiers: false);
+                isMetadataVirtualIgnoringModifiers: false,
+                isExpressionBodied: false);
         }
 
         protected void AssignTypeMapAndTypeParameters(TypeMap typeMap, ImmutableArray<TypeParameterSymbol> typeParameters)
@@ -226,10 +227,5 @@ public sealed override bool IsImplicitlyDeclared
         {
             get { return true; }
         }
-
-        internal override bool IsExpressionBodied
-        {
-            get { return false; }
-        }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Source/SourceConstructorSymbol.cs

@@ -12,7 +12,6 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
     internal sealed class SourceConstructorSymbol : SourceConstructorSymbolBase
     {
-        private readonly bool _isExpressionBodied;
         private readonly bool _hasThisInitializer;
 
         public static SourceConstructorSymbol CreateConstructorSymbol(
@@ -35,14 +34,14 @@ private SourceConstructorSymbol(
              base(containingType, location, syntax, SyntaxFacts.HasYieldOperations(syntax))
         {
             bool hasBlockBody = syntax.Body != null;
-            _isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
-            bool hasBody = hasBlockBody || _isExpressionBodied;
+            bool isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
+            bool hasBody = hasBlockBody || isExpressionBodied;
 
             _hasThisInitializer = syntax.Initializer?.Kind() == SyntaxKind.ThisConstructorInitializer;
 
             bool modifierErrors;
             var declarationModifiers = this.MakeModifiers(syntax.Modifiers, methodKind, hasBody, location, diagnostics, out modifierErrors);
-            this.MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExtensionMethod: false, isNullableAnalysisEnabled: isNullableAnalysisEnabled);
+            this.MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExpressionBodied: isExpressionBodied, isExtensionMethod: false, isNullableAnalysisEnabled: isNullableAnalysisEnabled);
 
             if (syntax.Identifier.ValueText != containingType.Name)
             {
@@ -163,14 +162,6 @@ internal override OneOrMany<SyntaxList<AttributeListSyntax>> GetAttributeDeclara
             return OneOrMany.Create(((ConstructorDeclarationSyntax)this.SyntaxNode).AttributeLists);
         }
 
-        internal override bool IsExpressionBodied
-        {
-            get
-            {
-                return _isExpressionBodied;
-            }
-        }
-
         internal override bool IsNullableAnalysisEnabled()
         {
             return _hasThisInitializer ?

src/Compilers/CSharp/Portable/Symbols/Source/SourceCustomEventAccessorSymbol.cs

@@ -4,6 +4,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -32,7 +33,8 @@ internal SourceCustomEventAccessorSymbol(
                    syntax.Keyword.GetLocation(), explicitlyImplementedEventOpt, aliasQualifierOpt,
                    isAdder: syntax.Kind() == SyntaxKind.AddAccessorDeclaration,
                    isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
-                   isNullableAnalysisEnabled: isNullableAnalysisEnabled)
+                   isNullableAnalysisEnabled: isNullableAnalysisEnabled,
+                   isExpressionBodied: syntax is { Body: null, ExpressionBody: not null })
         {
             Debug.Assert(syntax != null);
             Debug.Assert(syntax.Kind() == SyntaxKind.AddAccessorDeclaration || syntax.Kind() == SyntaxKind.RemoveAccessorDeclaration);
@@ -91,16 +93,5 @@ internal override bool GenerateDebugInfo
         {
             get { return true; }
         }
-
-        internal override bool IsExpressionBodied
-        {
-            get
-            {
-                var syntax = GetSyntax();
-                var hasBody = syntax.Body != null;
-                var hasExpressionBody = syntax.ExpressionBody != null;
-                return !hasBody && hasExpressionBody;
-            }
-        }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Source/SourceDelegateMethodSymbol.cs

@@ -28,7 +28,8 @@ protected SourceDelegateMethodSymbol(
             : base(delegateType, syntax.GetReference(), location: syntax.Identifier.GetLocation(), isIterator: false)
         {
             _returnType = returnType;
-            this.MakeFlags(methodKind, declarationModifiers, _returnType.IsVoidType(), isExtensionMethod: false, isNullableAnalysisEnabled: false);
+            this.MakeFlags(
+                methodKind, declarationModifiers, _returnType.IsVoidType(), isExpressionBodied: false, isExtensionMethod: false, isNullableAnalysisEnabled: false);
         }
 
         internal sealed override ExecutableCodeBinder TryGetBodyBinder(BinderFactory binderFactoryOpt = null, bool ignoreAccessibility = false) => throw ExceptionUtilities.Unreachable();
@@ -176,11 +177,6 @@ public sealed override bool IsImplicitlyDeclared
             }
         }
 
-        internal override bool IsExpressionBodied
-        {
-            get { return false; }
-        }
-
         internal override bool GenerateDebugInfo
         {
             get { return false; }

src/Compilers/CSharp/Portable/Symbols/Source/SourceDestructorSymbol.cs

@@ -14,7 +14,6 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
     internal sealed class SourceDestructorSymbol : SourceMemberMethodSymbol
     {
         private TypeWithAnnotations _lazyReturnType;
-        private readonly bool _isExpressionBodied;
 
         internal SourceDestructorSymbol(
             SourceMemberContainerTypeSymbol containingType,
@@ -28,25 +27,26 @@ internal SourceDestructorSymbol(
 
             bool modifierErrors;
             var declarationModifiers = MakeModifiers(syntax.Modifiers, location, diagnostics, out modifierErrors);
-            this.MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExtensionMethod: false, isNullableAnalysisEnabled: isNullableAnalysisEnabled);
+
+            bool hasBlockBody = syntax.Body != null;
+            bool isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
+
+            this.MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExpressionBodied: isExpressionBodied, isExtensionMethod: false, isNullableAnalysisEnabled: isNullableAnalysisEnabled);
 
             if (syntax.Identifier.ValueText != containingType.Name)
             {
                 diagnostics.Add(ErrorCode.ERR_BadDestructorName, syntax.Identifier.GetLocation());
             }
 
-            bool hasBlockBody = syntax.Body != null;
-            _isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
-
-            if (hasBlockBody || _isExpressionBodied)
+            if (hasBlockBody || isExpressionBodied)
             {
                 if (IsExtern)
                 {
                     diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
                 }
             }
 
-            if (!modifierErrors && !hasBlockBody && !_isExpressionBodied && !IsExtern)
+            if (!modifierErrors && !hasBlockBody && !isExpressionBodied && !IsExtern)
             {
                 diagnostics.Add(ErrorCode.ERR_ConcreteMissingBody, location, this);
             }
@@ -142,14 +142,6 @@ public override string Name
             get { return WellKnownMemberNames.DestructorName; }
         }
 
-        internal override bool IsExpressionBodied
-        {
-            get
-            {
-                return _isExpressionBodied;
-            }
-        }
-
         internal override OneOrMany<SyntaxList<AttributeListSyntax>> GetAttributeDeclarations()
         {
             // destructors can't have return type attributes

src/Compilers/CSharp/Portable/Symbols/Source/SourceEventAccessorSymbol.cs

@@ -29,7 +29,8 @@ public SourceEventAccessorSymbol(
             string aliasQualifierOpt,
             bool isAdder,
             bool isIterator,
-            bool isNullableAnalysisEnabled)
+            bool isNullableAnalysisEnabled,
+            bool isExpressionBodied)
             : base(@event.containingType, syntaxReference, location, isIterator)
         {
             _event = @event;
@@ -56,6 +57,7 @@ public SourceEventAccessorSymbol(
                 isAdder ? MethodKind.EventAdd : MethodKind.EventRemove,
                 @event.Modifiers,
                 returnsVoid: false, // until we learn otherwise (in LazyMethodChecks).
+                isExpressionBodied: isExpressionBodied,
                 isExtensionMethod: false,
                 isNullableAnalysisEnabled: isNullableAnalysisEnabled,
                 isMetadataVirtualIgnoringModifiers: @event.IsExplicitInterfaceImplementation && (@event.Modifiers & DeclarationModifiers.Static) == 0);
@@ -246,11 +248,5 @@ protected string GetOverriddenAccessorName(SourceEventSymbol @event, bool isAdde
 
             return null;
         }
-
-        internal override bool IsExpressionBodied
-        {
-            // Events cannot be expression-bodied
-            get { return false; }
-        }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberMethodSymbol.cs

@@ -24,22 +24,31 @@ protected struct Flags
         {
             // We currently pack everything into a 32 bit int with the following layout:
             //
-            // |              |n|vvv|yy|s|r|q|z|wwwww|
+            // |              |a|b|e|n|vvv|yy|s|r|q|z|kk|wwwww|
             // 
             // w = method kind.  5 bits.
+            // k = ref kind.  2 bits.
             // z = isExtensionMethod. 1 bit.
             // q = isMetadataVirtualIgnoringInterfaceChanges. 1 bit.
             // r = isMetadataVirtual. 1 bit. (At least as true as isMetadataVirtualIgnoringInterfaceChanges.)
             // s = isMetadataVirtualLocked. 1 bit.
             // y = ReturnsVoid. 2 bits.
             // v = NullableContext. 3 bits.
             // n = IsNullableAnalysisEnabled. 1 bit.
+            // e = IsExpressionBody. 1 bit.
+            // b = HasAnyBody. 1 bit.
+            // a = IsVarArg. 1 bit
             private int _flags;
 
             private const int MethodKindOffset = 0;
             private const int MethodKindSize = 5;
+            private const int MethodKindMask = (1 << MethodKindSize) - 1;
+
+            private const int RefKindOffset = MethodKindOffset + MethodKindSize;
+            private const int RefKindSize = 2;
+            private const int RefKindMask = (1 << RefKindSize) - 1;
 
-            private const int IsExtensionMethodOffset = MethodKindOffset + MethodKindSize;
+            private const int IsExtensionMethodOffset = RefKindOffset + RefKindSize;
             private const int IsExtensionMethodSize = 1;
 
             private const int IsMetadataVirtualIgnoringInterfaceChangesOffset = IsExtensionMethodOffset + IsExtensionMethodSize;
@@ -56,24 +65,33 @@ protected struct Flags
 
             private const int NullableContextOffset = ReturnsVoidOffset + ReturnsVoidSize;
             private const int NullableContextSize = 3;
+            private const int NullableContextMask = (1 << NullableContextSize) - 1;
 
             private const int IsNullableAnalysisEnabledOffset = NullableContextOffset + NullableContextSize;
-#pragma warning disable IDE0051 // Remove unused private members
             private const int IsNullableAnalysisEnabledSize = 1;
-#pragma warning restore IDE0051 // Remove unused private members
 
-            private const int MethodKindMask = (1 << MethodKindSize) - 1;
+            private const int IsExpressionBodiedOffset = IsNullableAnalysisEnabledOffset + IsNullableAnalysisEnabledSize;
+            private const int IsExpressionBodiedSize = 1;
+
+            private const int HasAnyBodyOffset = IsExpressionBodiedOffset + IsExpressionBodiedSize;
+            private const int HasAnyBodySize = 1;
 
+            private const int IsVarArgOffset = HasAnyBodyOffset + HasAnyBodySize;
+#pragma warning disable IDE0051 // Remove unused private members
+            private const int IsVarArgSize = 1;
+#pragma warning restore IDE0051 // Remove unused private members
+
+            private const int HasAnyBodyBit = 1 << HasAnyBodyOffset;
+            private const int IsExpressionBodiedBit = 1 << IsExpressionBodiedOffset;
             private const int IsExtensionMethodBit = 1 << IsExtensionMethodOffset;
             private const int IsMetadataVirtualIgnoringInterfaceChangesBit = 1 << IsMetadataVirtualIgnoringInterfaceChangesOffset;
             private const int IsMetadataVirtualBit = 1 << IsMetadataVirtualIgnoringInterfaceChangesOffset;
             private const int IsMetadataVirtualLockedBit = 1 << IsMetadataVirtualLockedOffset;
+            private const int IsVarArgBit = 1 << IsVarArgOffset;
 
             private const int ReturnsVoidBit = 1 << ReturnsVoidOffset;
             private const int ReturnsVoidIsSetBit = 1 << ReturnsVoidOffset + 1;
 
-            private const int NullableContextMask = (1 << NullableContextSize) - 1;
-
             private const int IsNullableAnalysisEnabledBit = 1 << IsNullableAnalysisEnabledOffset;
 
             public bool TryGetReturnsVoid(out bool value)
@@ -93,9 +111,25 @@ public MethodKind MethodKind
                 get { return (MethodKind)((_flags >> MethodKindOffset) & MethodKindMask); }
             }
 
+            public RefKind RefKind
+            {
+                get { return (RefKind)((_flags >> RefKindOffset) & RefKindMask); }
+            }
+
+            public bool HasAnyBody
+            {
+                get { return (_flags & HasAnyBodyBit) != 0; }
+            }
+
+            public bool IsExpressionBodied
+            {
+                get { return (_flags & IsExpressionBodiedBit) != 0; }
+            }
+
             public bool IsExtensionMethod
             {
                 get { return (_flags & IsExtensionMethodBit) != 0; }
+                set { ThreadSafeFlagOperations.Set(ref _flags, value ? IsExtensionMethodBit : 0); }
             }
 
             public bool IsNullableAnalysisEnabled
@@ -108,11 +142,17 @@ public bool IsMetadataVirtualLocked
                 get { return (_flags & IsMetadataVirtualLockedBit) != 0; }
             }
 
+            public bool IsVarArg
+            {
+                get { return (_flags & IsVarArgBit) != 0; }
+            }
+
 #if DEBUG
             static Flags()
             {
                 // Verify masks are sufficient for values.
                 Debug.Assert(EnumUtilities.ContainsAllValues<MethodKind>(MethodKindMask));
+                Debug.Assert(EnumUtilities.ContainsAllValues<RefKind>(RefKindMask));
                 Debug.Assert(EnumUtilities.ContainsAllValues<NullableContextKind>(NullableContextMask));
             }
 #endif
@@ -126,19 +166,22 @@ public Flags(
                 MethodKind methodKind,
                 DeclarationModifiers declarationModifiers,
                 bool returnsVoid,
+                bool isExpressionBodied,
                 bool isExtensionMethod,
                 bool isNullableAnalysisEnabled,
                 bool isMetadataVirtualIgnoringModifiers = false)
             {
                 bool isMetadataVirtual = isMetadataVirtualIgnoringModifiers || ModifiersRequireMetadataVirtual(declarationModifiers);
 
                 int methodKindInt = ((int)methodKind & MethodKindMask) << MethodKindOffset;
+                int isExpressionBodyInt = isExpressionBodied ? IsExpressionBodiedBit : 0;
                 int isExtensionMethodInt = isExtensionMethod ? IsExtensionMethodBit : 0;
                 int isNullableAnalysisEnabledInt = isNullableAnalysisEnabled ? IsNullableAnalysisEnabledBit : 0;
                 int isMetadataVirtualIgnoringInterfaceImplementationChangesInt = isMetadataVirtual ? IsMetadataVirtualIgnoringInterfaceChangesBit : 0;
                 int isMetadataVirtualInt = isMetadataVirtual ? IsMetadataVirtualBit : 0;
 
                 _flags = methodKindInt
+                    | isExpressionBodyInt
                     | isExtensionMethodInt
                     | isNullableAnalysisEnabledInt
                     | isMetadataVirtualIgnoringInterfaceImplementationChangesInt
@@ -147,6 +190,17 @@ public Flags(
                     | ReturnsVoidIsSetBit;
             }
 
+            /// <summary>
+            /// Only allowed to be called in constructors of SourceMemberMethodSymbol (and derived constructors), so
+            /// does not need ThreadSafe operations.
+            /// </summary>
+            public void SetOrdinaryMethodFlags(RefKind refKind, bool hasAnyBody, bool isVarArg)
+            {
+                _flags |= ((int)refKind & RefKindMask) << RefKindOffset;
+                _flags |= hasAnyBody ? HasAnyBodyBit : 0;
+                _flags |= isVarArg ? IsVarArgBit : 0;
+            }
+
             public bool IsMetadataVirtual(bool ignoreInterfaceImplementationChanges = false)
             {
                 // This flag is immutable, so there's no reason to set a lock bit, as we do below.
@@ -292,12 +346,13 @@ protected void MakeFlags(
             MethodKind methodKind,
             DeclarationModifiers declarationModifiers,
             bool returnsVoid,
+            bool isExpressionBodied,
             bool isExtensionMethod,
             bool isNullableAnalysisEnabled,
             bool isMetadataVirtualIgnoringModifiers = false)
         {
             DeclarationModifiers = declarationModifiers;
-            this.flags = new Flags(methodKind, declarationModifiers, returnsVoid, isExtensionMethod, isNullableAnalysisEnabled, isMetadataVirtualIgnoringModifiers);
+            this.flags = new Flags(methodKind, declarationModifiers, returnsVoid, isExpressionBodied, isExtensionMethod, isNullableAnalysisEnabled, isMetadataVirtualIgnoringModifiers);
         }
 
         protected void SetReturnsVoid(bool returnsVoid)
@@ -1003,7 +1058,7 @@ protected void CheckFeatureAvailabilityAndRuntimeSupport(SyntaxNode declarationS
         /// If the method has both block body and an expression body
         /// present, this is not treated as expression-bodied.
         /// </remarks>
-        internal abstract bool IsExpressionBodied { get; }
+        internal bool IsExpressionBodied => flags.IsExpressionBodied;
 
         internal override int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree)
         {