Merge branch 'master' of https://github.com/dotnet/roslyn into typeswitch-rename-feature

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

@@ -463,6 +463,7 @@ private TypeSymbol BindTupleType(TupleTypeSyntax syntax, DiagnosticBag diagnosti
 
             if (typesArray.Length < 2)
             {
+                elementNames?.Free();
                 return new ExtendedErrorTypeSymbol(this.Compilation.Assembly.GlobalNamespace, LookupResultKind.NotCreatable, diagnostics.Add(ErrorCode.ERR_TupleTooFewElements, syntax.Location));
             }
 
@@ -500,7 +501,7 @@ private static void CollectTupleFieldMemberNames(string name, int position, int
             }
         }
 
-        private static bool CheckTupleMemberName(string name, int position, CSharpSyntaxNode syntax, DiagnosticBag diagnostics, PooledHashSet<string> uniqueFieldNames)
+        private static bool CheckTupleMemberName(string name, int index, CSharpSyntaxNode syntax, DiagnosticBag diagnostics, PooledHashSet<string> uniqueFieldNames)
         {
             int reserved = TupleTypeSymbol.IsElementNameReserved(name);
             if (reserved == 0)
@@ -508,7 +509,7 @@ private static bool CheckTupleMemberName(string name, int position, CSharpSyntax
                 Error(diagnostics, ErrorCode.ERR_TupleReservedMemberNameAnyPosition, syntax, name);
                 return false;
             }
-            else if (reserved > 0 && reserved != position + 1)
+            else if (reserved > 0 && reserved != index + 1)
             {
                 Error(diagnostics, ErrorCode.ERR_TupleReservedMemberName, syntax, name, reserved);
                 return false;

src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Types.cs

@@ -444,17 +444,14 @@ private void AddTupleTypeName(INamedTypeSymbol symbol)
 
             AddPunctuation(SyntaxKind.OpenParenToken);
 
-            bool first = true;
             for (int i = 0; i < elementTypes.Length; i++)
             {
-                if (!first)
+                if (i != 0)
                 {
                     AddPunctuation(SyntaxKind.CommaToken);
                     AddSpace();
                 }
 
-                first = false;
-
                 elementTypes[i].Accept(this.NotFirstVisitor);
                 if (hasNames && elementNames[i] != null)
                 {

src/Compilers/CSharp/Portable/Symbols/Tuples/TupleTypeSymbol.cs

@@ -54,7 +54,6 @@ private TupleTypeSymbol(Location locationOpt, NamedTypeSymbol underlyingType, Im
         private TupleTypeSymbol(ImmutableArray<Location> locations, NamedTypeSymbol underlyingType, ImmutableArray<Location> elementLocations, ImmutableArray<string> elementNames, ImmutableArray<TypeSymbol> elementTypes)
             : base(underlyingType)
         {
-            Debug.Assert(elementLocations.IsDefault || elementNames.IsDefault || elementLocations.Length == elementNames.Length);
             Debug.Assert(elementLocations.IsDefault || elementLocations.Length == elementTypes.Length);
             Debug.Assert(elementNames.IsDefault || elementNames.Length == elementTypes.Length);
             Debug.Assert(!underlyingType.IsTupleType);
@@ -186,29 +185,20 @@ private static NamedTypeSymbol ReplaceRestExtensionType(NamedTypeSymbol tupleCom
 
             for (int i = 0; i < RestPosition - 1; i++)
             {
-                if (!modifiers.IsDefault && !modifiers[i].IsDefaultOrEmpty)
-                {
-                    typeArgumentsBuilder.Add(new TypeWithModifiers(arguments[i], modifiers[i]));
-                }
-                else
-                {
-                    typeArgumentsBuilder.Add(new TypeWithModifiers(arguments[i]));
-                }
+                typeArgumentsBuilder.Add(new TypeWithModifiers(arguments[i], GetModifiers(modifiers, i)));
             }
 
-            if (!modifiers.IsDefault && !modifiers[RestPosition - 1].IsDefaultOrEmpty)
-            {
-                typeArgumentsBuilder.Add(new TypeWithModifiers(extensionTuple, modifiers[RestPosition - 1]));
-            }
-            else
-            {
-                typeArgumentsBuilder.Add(new TypeWithModifiers(extensionTuple));
-            }
+            typeArgumentsBuilder.Add(new TypeWithModifiers(extensionTuple, GetModifiers(modifiers, RestPosition - 1)));
 
             tupleCompatibleType = tupleCompatibleType.ConstructedFrom.Construct(typeArgumentsBuilder.ToImmutable(), unbound: false);
             return tupleCompatibleType;
         }
 
+        private static ImmutableArray<CustomModifier> GetModifiers(ImmutableArray<ImmutableArray<CustomModifier>> modifiers, int i)
+        {
+            return modifiers.IsDefaultOrEmpty? ImmutableArray<CustomModifier>.Empty: modifiers[i];
+        }
+
         /// <summary>
         /// Copy this tuple, but modify it to use the new underlying type.
         /// </summary>
@@ -569,7 +559,7 @@ internal static int IsElementNameReserved(string name)
         /// <param name="relativeMember">A reference to a well-known member type descriptor. Note however that the type in that descriptor is ignored here.</param>
         internal static Symbol GetWellKnownMemberInType(NamedTypeSymbol type, WellKnownMember relativeMember)
         {
-            Debug.Assert(relativeMember >= 0 && relativeMember < WellKnownMember.Count);
+            Debug.Assert(relativeMember >= WellKnownMember.System_ValueTuple_T1__Item1 && relativeMember <= WellKnownMember.System_ValueTuple_TRest__ctor);
             Debug.Assert(type.IsDefinition);
 
             MemberDescriptor relativeDescriptor = WellKnownMembers.GetDescriptor(relativeMember);
@@ -946,60 +936,61 @@ private static void CollectTargetTupleFields(NamedTypeSymbol underlying, ArrayBu
         {
             get
             {
-                if (_lazyUnderlyingDefinitionToMemberMap == null)
-                {
-                    var map = new SmallDictionary<Symbol, Symbol>(ReferenceEqualityComparer.Instance);
-
-                    var underlyingDefinition = _underlyingType.OriginalDefinition;
-                    var members = GetMembers();
+                return _lazyUnderlyingDefinitionToMemberMap ??
+                    (_lazyUnderlyingDefinitionToMemberMap = ComputeDefinitionToMemberMap()); 
+            }
+        }
 
-                    // Go in reverse because we want members with default name, which precede the ones with
-                    // friendly names, to be in the map.  
-                    for (int i = members.Length - 1; i >= 0; i--)
-                    {
-                        var member = members[i];
-                        switch (member.Kind)
-                        {
-                            case SymbolKind.Method:
-                                map.Add(((MethodSymbol)member).TupleUnderlyingMethod.OriginalDefinition, member);
-                                break;
+        private SmallDictionary<Symbol, Symbol> ComputeDefinitionToMemberMap()
+        {
+            var map = new SmallDictionary<Symbol, Symbol>(ReferenceEqualityComparer.Instance);
 
-                            case SymbolKind.Field:
-                                var tupleUnderlyingField = ((FieldSymbol)member).TupleUnderlyingField;
-                                if ((object)tupleUnderlyingField != null)
-                                {
-                                    map[tupleUnderlyingField.OriginalDefinition] = member;
-                                }
-                                break;
+            var underlyingDefinition = _underlyingType.OriginalDefinition;
+            var members = GetMembers();
 
-                            case SymbolKind.Property:
-                                map.Add(((PropertySymbol)member).TupleUnderlyingProperty.OriginalDefinition, member);
-                                break;
+            // Go in reverse because we want members with default name, which precede the ones with
+            // friendly names, to be in the map.  
+            for (int i = members.Length - 1; i >= 0; i--)
+            {
+                var member = members[i];
+                switch (member.Kind)
+                {
+                    case SymbolKind.Method:
+                        map.Add(((MethodSymbol)member).TupleUnderlyingMethod.OriginalDefinition, member);
+                        break;
 
-                            case SymbolKind.Event:
-                                var underlyingEvent = ((EventSymbol)member).TupleUnderlyingEvent;
-                                var underlyingAssociatedField = underlyingEvent.AssociatedField;
-                                // The field is not part of the members list
-                                if ((object)underlyingAssociatedField != null)
-                                {
-                                    Debug.Assert((object)underlyingAssociatedField.ContainingSymbol == _underlyingType);
-                                    Debug.Assert(_underlyingType.GetMembers(underlyingAssociatedField.Name).IndexOf(underlyingAssociatedField) < 0);
-                                    map.Add(underlyingAssociatedField.OriginalDefinition, new TupleFieldSymbol(this, underlyingAssociatedField, -i - 1));
-                                }
+                    case SymbolKind.Field:
+                        var tupleUnderlyingField = ((FieldSymbol)member).TupleUnderlyingField;
+                        if ((object)tupleUnderlyingField != null)
+                        {
+                            map[tupleUnderlyingField.OriginalDefinition] = member;
+                        }
+                        break;
 
-                                map.Add(underlyingEvent.OriginalDefinition, member);
-                                break;
+                    case SymbolKind.Property:
+                        map.Add(((PropertySymbol)member).TupleUnderlyingProperty.OriginalDefinition, member);
+                        break;
 
-                            default:
-                                throw ExceptionUtilities.UnexpectedValue(member.Kind);
+                    case SymbolKind.Event:
+                        var underlyingEvent = ((EventSymbol)member).TupleUnderlyingEvent;
+                        var underlyingAssociatedField = underlyingEvent.AssociatedField;
+                        // The field is not part of the members list
+                        if ((object)underlyingAssociatedField != null)
+                        {
+                            Debug.Assert((object)underlyingAssociatedField.ContainingSymbol == _underlyingType);
+                            Debug.Assert(_underlyingType.GetMembers(underlyingAssociatedField.Name).IndexOf(underlyingAssociatedField) < 0);
+                            map.Add(underlyingAssociatedField.OriginalDefinition, new TupleFieldSymbol(this, underlyingAssociatedField, -i - 1));
                         }
-                    }
 
-                    _lazyUnderlyingDefinitionToMemberMap = map;
-                }
+                        map.Add(underlyingEvent.OriginalDefinition, member);
+                        break;
 
-                return _lazyUnderlyingDefinitionToMemberMap;
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(member.Kind);
+                }
             }
+
+            return map;
         }
 
         public TMember GetTupleMemberSymbolForUnderlyingMember<TMember>(TMember underlyingMemberOpt) where TMember : Symbol

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedEventSymbol.cs

@@ -51,41 +51,6 @@ internal override bool HasSpecialName
             }
         }
 
-        public override abstract TypeSymbol Type
-        {
-            get;
-        }
-
-        public override abstract MethodSymbol AddMethod
-        {
-            get;
-        }
-
-        public override abstract MethodSymbol RemoveMethod
-        {
-            get;
-        }
-
-        internal override abstract FieldSymbol AssociatedField
-        {
-            get;
-        }
-
-        internal override abstract bool IsExplicitInterfaceImplementation
-        {
-            get;
-        }
-
-        public override abstract ImmutableArray<EventSymbol> ExplicitInterfaceImplementations
-        {
-            get;
-        }
-
-        public override abstract Symbol ContainingSymbol
-        {
-            get;
-        }
-
         public override string Name
         {
             get
@@ -179,13 +144,6 @@ internal override ObsoleteAttributeData ObsoleteAttributeData
             }
         }
 
-        public override abstract ImmutableArray<CSharpAttributeData> GetAttributes();
-
-        internal override abstract bool MustCallMethodsDirectly
-        {
-            get;
-        }
-
         public override bool IsWindowsRuntimeEvent
         {
             get

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedFieldSymbol.cs

@@ -4,7 +4,6 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.Threading;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -41,18 +40,6 @@ public override bool IsImplicitlyDeclared
             get { return _underlyingField.IsImplicitlyDeclared; }
         }
 
-        internal override abstract TypeSymbol GetFieldType(ConsList<FieldSymbol> fieldsBeingBound);
-
-        public override abstract ImmutableArray<CustomModifier> CustomModifiers
-        {
-            get;
-        }
-
-        public override abstract Symbol ContainingSymbol
-        {
-            get;
-        }
-
         public override Accessibility DeclaredAccessibility
         {
             get
@@ -61,8 +48,6 @@ public override Accessibility DeclaredAccessibility
             }
         }
 
-        public override abstract ImmutableArray<CSharpAttributeData> GetAttributes();
-
         public override string Name
         {
             get
@@ -132,11 +117,6 @@ internal override ImmutableArray<byte> MarshallingDescriptor
             }
         }
 
-        public override abstract Symbol AssociatedSymbol
-        {
-            get;
-        }
-
         public override bool IsReadOnly
         {
             get

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedMethodSymbol.cs

@@ -2,7 +2,6 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.Globalization;
 using System.Threading;
 
@@ -50,21 +49,6 @@ public override int Arity
             }
         }
 
-        public override abstract ImmutableArray<TypeParameterSymbol> TypeParameters
-        {
-            get;
-        }
-
-        public override abstract ImmutableArray<TypeSymbol> TypeArguments
-        {
-            get;
-        }
-
-        public override abstract bool ReturnsVoid
-        {
-            get;
-        }
-
         internal override RefKind RefKind
         {
             get
@@ -73,31 +57,11 @@ internal override RefKind RefKind
             }
         }
 
-        public override abstract TypeSymbol ReturnType
-        {
-            get;
-        }
-
-        public override abstract ImmutableArray<CustomModifier> ReturnTypeCustomModifiers
-        {
-            get;
-        }
-
         internal override int ParameterCount
         {
             get { return UnderlyingMethod.ParameterCount; }
         }
 
-        public override abstract ImmutableArray<ParameterSymbol> Parameters
-        {
-            get;
-        }
-
-        public override abstract Symbol AssociatedSymbol
-        {
-            get;
-        }
-
         public override bool IsExtensionMethod
         {
             get
@@ -114,11 +78,6 @@ public override bool HidesBaseMethodsByName
             }
         }
 
-        public override abstract Symbol ContainingSymbol
-        {
-            get;
-        }
-
         public override ImmutableArray<Location> Locations
         {
             get
@@ -261,11 +220,6 @@ internal override ImmutableArray<string> GetAppliedConditionalSymbols()
             return UnderlyingMethod.GetAppliedConditionalSymbols();
         }
 
-        public override abstract ImmutableArray<CSharpAttributeData> GetAttributes();
-
-        // Get return type attributes
-        public override abstract ImmutableArray<CSharpAttributeData> GetReturnTypeAttributes();
-
         internal override ObsoleteAttributeData ObsoleteAttributeData
         {
             get
@@ -319,16 +273,6 @@ internal override Microsoft.Cci.CallingConvention CallingConvention
             }
         }
 
-        internal override abstract bool IsExplicitInterfaceImplementation
-        {
-            get;
-        }
-
-        public override abstract ImmutableArray<MethodSymbol> ExplicitInterfaceImplementations
-        {
-            get;
-        }
-
         internal override bool IsAccessCheckedOnOverride
         {
             get
@@ -376,7 +320,5 @@ internal override bool GenerateDebugInfo
                 return UnderlyingMethod.GenerateDebugInfo;
             }
         }
-
-        internal override abstract int CalculateLocalSyntaxOffset(int localPosition, SyntaxTree localTree);
     }
 }

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedNamedTypeSymbol.cs

@@ -6,7 +6,6 @@
 using System.Globalization;
 using System.Runtime.InteropServices;
 using System.Threading;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -51,36 +50,6 @@ public override int Arity
             }
         }
 
-        public override abstract ImmutableArray<TypeParameterSymbol> TypeParameters
-        {
-            get;
-        }
-
-        internal override abstract ImmutableArray<TypeSymbol> TypeArgumentsNoUseSiteDiagnostics
-        {
-            get;
-        }
-
-        internal override abstract bool HasTypeArgumentsCustomModifiers
-        {
-            get;
-        }
-
-        internal override abstract ImmutableArray<ImmutableArray<CustomModifier>> TypeArgumentsCustomModifiers
-        {
-            get;
-        }
-
-        public override abstract NamedTypeSymbol ConstructedFrom
-        {
-            get;
-        }
-
-        public override abstract NamedTypeSymbol EnumUnderlyingType
-        {
-            get;
-        }
-
         public override bool MightContainExtensionMethods
         {
             get
@@ -126,33 +95,6 @@ public override string GetDocumentationCommentXml(CultureInfo preferredCulture =
             return _underlyingType.GetDocumentationCommentXml(preferredCulture, expandIncludes, cancellationToken);
         }
 
-        public override abstract IEnumerable<string> MemberNames
-        {
-            get;
-        }
-
-        public override abstract ImmutableArray<Symbol> GetMembers();
-
-        public override abstract ImmutableArray<Symbol> GetMembers(string name);
-
-        internal override abstract IEnumerable<FieldSymbol> GetFieldsToEmit();
-
-        internal override abstract IEnumerable<MethodSymbol> GetMethodsToEmit();
-
-        internal override abstract IEnumerable<PropertySymbol> GetPropertiesToEmit();
-
-        internal override abstract IEnumerable<EventSymbol> GetEventsToEmit();
-
-        internal override abstract ImmutableArray<Symbol> GetEarlyAttributeDecodingMembers();
-
-        internal override abstract ImmutableArray<Symbol> GetEarlyAttributeDecodingMembers(string name);
-
-        public override abstract ImmutableArray<NamedTypeSymbol> GetTypeMembers();
-
-        public override abstract ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name);
-
-        public override abstract ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name, int arity);
-
         public override Accessibility DeclaredAccessibility
         {
             get
@@ -177,11 +119,6 @@ internal override bool IsInterface
             }
         }
 
-        public override abstract Symbol ContainingSymbol
-        {
-            get;
-        }
-
         public override ImmutableArray<Location> Locations
         {
             get
@@ -238,33 +175,6 @@ internal override bool IsMetadataSealed
             }
         }
 
-        public override abstract ImmutableArray<CSharpAttributeData> GetAttributes();
-
-        internal override abstract IEnumerable<CSharpAttributeData> GetCustomAttributesToEmit(ModuleCompilationState compilationState);
-
-        internal override abstract NamedTypeSymbol BaseTypeNoUseSiteDiagnostics
-        {
-            get;
-        }
-
-        internal override abstract ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList<Symbol> basesBeingResolved);
-
-        internal override abstract ImmutableArray<NamedTypeSymbol> GetInterfacesToEmit();
-
-        internal override abstract NamedTypeSymbol GetDeclaredBaseType(ConsList<Symbol> basesBeingResolved);
-
-        internal override abstract ImmutableArray<NamedTypeSymbol> GetDeclaredInterfaces(ConsList<Symbol> basesBeingResolved);
-
-        internal override abstract NamedTypeSymbol ComImportCoClass
-        {
-            get;
-        }
-
-        internal override abstract bool IsComImport
-        {
-            get;
-        }
-
         internal override ObsoleteAttributeData ObsoleteAttributeData
         {
             get { return _underlyingType.ObsoleteAttributeData; }

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedParameterSymbol.cs

@@ -34,11 +34,6 @@ public ParameterSymbol UnderlyingParameter
             }
         }
 
-        public abstract override Symbol ContainingSymbol
-        {
-            get;
-        }
-
         #region Forwarded
 
         public override TypeSymbol Type

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedPropertySymbol.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Globalization;
@@ -49,21 +48,6 @@ internal override RefKind RefKind
             }
         }
 
-        public override abstract TypeSymbol Type
-        {
-            get;
-        }
-
-        public override abstract ImmutableArray<CustomModifier> TypeCustomModifiers
-        {
-            get;
-        }
-
-        public override abstract ImmutableArray<ParameterSymbol> Parameters
-        {
-            get;
-        }
-
         public override bool IsIndexer
         {
             get
@@ -72,16 +56,6 @@ public override bool IsIndexer
             }
         }
 
-        public override abstract MethodSymbol GetMethod
-        {
-            get;
-        }
-
-        public override abstract MethodSymbol SetMethod
-        {
-            get;
-        }
-
         internal override Microsoft.Cci.CallingConvention CallingConvention
         {
             get
@@ -90,21 +64,6 @@ internal override Microsoft.Cci.CallingConvention CallingConvention
             }
         }
 
-        internal override abstract bool IsExplicitInterfaceImplementation
-        {
-            get;
-        }
-
-        public override abstract ImmutableArray<PropertySymbol> ExplicitInterfaceImplementations
-        {
-            get;
-        }
-
-        public override abstract Symbol ContainingSymbol
-        {
-            get;
-        }
-
         public override string Name
         {
             get
@@ -206,13 +165,6 @@ internal override ObsoleteAttributeData ObsoleteAttributeData
             }
         }
 
-        public override abstract ImmutableArray<CSharpAttributeData> GetAttributes();
-
-        internal override abstract bool MustCallMethodsDirectly
-        {
-            get;
-        }
-
         public override string MetadataName
         {
             get

src/Compilers/CSharp/Portable/Symbols/Wrapped/WrappedTypeParameterSymbol.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Immutable;
-using System.Threading;
-using Roslyn.Utilities;
 using System.Diagnostics;
 using System.Globalization;
+using System.Threading;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -90,11 +89,6 @@ public override VarianceKind Variance
             }
         }
 
-        public override abstract Symbol ContainingSymbol
-        {
-            get;
-        }
-
         public override ImmutableArray<Location> Locations
         {
             get
@@ -111,8 +105,6 @@ public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences
             }
         }
 
-        public override abstract ImmutableArray<CSharpAttributeData> GetAttributes();
-
         public override string Name
         {
             get
@@ -130,13 +122,5 @@ internal override void EnsureAllConstraintsAreResolved()
         {
             _underlyingTypeParameter.EnsureAllConstraintsAreResolved();
         }
-
-        internal override abstract ImmutableArray<TypeSymbol> GetConstraintTypes(ConsList<TypeParameterSymbol> inProgress);
-
-        internal override abstract ImmutableArray<NamedTypeSymbol> GetInterfaces(ConsList<TypeParameterSymbol> inProgress);
-
-        internal override abstract NamedTypeSymbol GetEffectiveBaseClass(ConsList<TypeParameterSymbol> inProgress);
-
-        internal override abstract TypeSymbol GetDeducedBaseType(ConsList<TypeParameterSymbol> inProgress);
     }
 }