Remove dedicated tuple type symbol

docs/compilers/CSharp/Compiler Breaking Changes - post VS2019.md

@@ -78,3 +78,5 @@ could be different than the one that compiler used to find.
     ```
 
 11. Previously, the language version was not checked for `this ref` and `this in` orderings of parameter modifiers. In *Visual Studio 2019 version 16.4* these orderings produce an error with langversion below 7.2. See https://github.com/dotnet/roslyn/issues/38486
+
+12. In Visual Studio version 15.0 and onwards, the compiler would allow compiling some malformed definitions of the `System.ValueTuple` types. For instance, one with a private `Item1` field. In *Visual Studio 2019 version 16.5* such definitions produce warnings.

docs/contributing/Compiler Test Plan.md

@@ -40,7 +40,7 @@ This document provides guidance for thinking about language interactions and tes
     - events (including add/remove accessors)
 - Parameter modifiers (ref, out, in, params)
 - Attributes (including security attribute)
-- Generics (type arguments, variance, constraints including `class`, `struct`, `new()`, `unmanaged`)
+- Generics (type arguments, variance, constraints including `class`, `struct`, `new()`, `unmanaged`, `notnull`, types and interfaces with nullability)
 - Default and constant values
 - Partial classes
 - Literals

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

@@ -65,7 +65,7 @@ protected BoundExpression CreateConversion(
             {
                 if (source is BoundTupleLiteral sourceTuple)
                 {
-                    TupleTypeSymbol.ReportNamesMismatchesIfAny(destination, sourceTuple, diagnostics);
+                    NamedTypeSymbol.ReportTupleNamesMismatchesIfAny(destination, sourceTuple, diagnostics);
                 }
 
                 // identity tuple and switch conversions result in a converted expression
@@ -435,20 +435,19 @@ private BoundExpression CreateTupleLiteralConversion(SyntaxNode syntax, BoundTup
             NamedTypeSymbol targetType = (NamedTypeSymbol)destinationWithoutNullable;
             if (targetType.IsTupleType)
             {
-                var destTupleType = (TupleTypeSymbol)targetType;
-
-                TupleTypeSymbol.ReportNamesMismatchesIfAny(targetType, sourceTuple, diagnostics);
+                NamedTypeSymbol.ReportTupleNamesMismatchesIfAny(targetType, sourceTuple, diagnostics);
 
                 // do not lose the original element names and locations in the literal if different from names in the target
                 //
                 // the tuple has changed the type of elements due to target-typing, 
                 // but element names has not changed and locations of their declarations 
                 // should not be confused with element locations on the target type.
-                var sourceType = sourceTuple.Type as TupleTypeSymbol;
 
-                if ((object)sourceType != null)
+                var sourceType = sourceTuple.Type as NamedTypeSymbol;
+
+                if (sourceTuple.Type is { IsTupleType: true })
                 {
-                    targetType = sourceType.WithUnderlyingType(destTupleType.UnderlyingNamedType);
+                    targetType = targetType.WithTupleDataFrom(sourceType);
                 }
                 else
                 {
@@ -460,16 +459,17 @@ private BoundExpression CreateTupleLiteralConversion(SyntaxNode syntax, BoundTup
                         locationBuilder.Add(argument.NameColon?.Name.Location);
                     }
 
-                    targetType = destTupleType.WithElementNames(sourceTuple.ArgumentNamesOpt,
-                                                                tupleSyntax.Location,
-                                                                locationBuilder.ToImmutableAndFree());
+                    targetType = targetType.WithElementNames(sourceTuple.ArgumentNamesOpt,
+                        locationBuilder.ToImmutableAndFree(),
+                        errorPositions: default,
+                        ImmutableArray.Create(tupleSyntax.Location));
                 }
             }
 
             var arguments = sourceTuple.Arguments;
             var convertedArguments = ArrayBuilder<BoundExpression>.GetInstance(arguments.Length);
 
-            var targetElementTypes = targetType.GetElementTypesOfTupleOrCompatible();
+            var targetElementTypes = targetType.TupleElementTypesWithAnnotations;
             Debug.Assert(targetElementTypes.Length == arguments.Length, "converting a tuple literal to incompatible type?");
             var underlyingConversions = conversionWithoutNullable.UnderlyingConversions;
 

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

@@ -92,12 +92,6 @@ private NamespaceOrTypeSymbol BindNamespaceOrTypeSymbolInCref(TypeSyntax syntax)
             NamespaceOrTypeSymbol namespaceOrTypeSymbol = BindNamespaceOrTypeSymbol(syntax, unusedDiagnostics).NamespaceOrTypeSymbol;
             unusedDiagnostics.Free();
 
-            // BindNamespaceOrTypeSymbol will wrap any tuple types in a TupleTypeSymbol. We unwrap it here, as doc comments don't consider the (T,T) form of tuples
-            if (namespaceOrTypeSymbol is TupleTypeSymbol t)
-            {
-                namespaceOrTypeSymbol = t.UnderlyingNamedType;
-            }
-
             Debug.Assert((object)namespaceOrTypeSymbol != null);
             return namespaceOrTypeSymbol;
         }

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

@@ -517,7 +517,7 @@ private static TypeSymbol MakeMergedTupleType(ArrayBuilder<DeconstructionVariabl
             // The tuple created here is not identical to the one created by
             // DeconstructionVariablesAsTuple. It represents a smaller
             // tree of types used for figuring out natural types in tuple literal.
-            return TupleTypeSymbol.Create(
+            return NamedTypeSymbol.CreateTuple(
                 locationOpt: null,
                 elementTypesWithAnnotations: typesWithAnnotationsBuilder.ToImmutableAndFree(),
                 elementLocations: locationsBuilder.ToImmutableAndFree(),
@@ -566,7 +566,7 @@ private BoundTupleExpression DeconstructionVariablesAsTuple(CSharpSyntaxNode syn
             ImmutableArray<bool> inferredPositions = tupleNames.IsDefault ? default : tupleNames.SelectAsArray(n => n != null);
             bool disallowInferredNames = this.Compilation.LanguageVersion.DisallowInferredTupleElementNames();
 
-            var type = TupleTypeSymbol.Create(
+            var type = NamedTypeSymbol.CreateTuple(
                 syntax.Location,
                 typesWithAnnotationsBuilder.ToImmutableAndFree(), locationsBuilder.ToImmutableAndFree(),
                 tupleNames, this.Compilation,

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

@@ -240,7 +240,7 @@ internal BoundExpression BindToTypeForErrorRecovery(BoundExpression expression,
                 return null;
             var discardedDiagnostics = DiagnosticBag.GetInstance();
             var result =
-                (!expression.NeedsToBeConverted() || expression.WasConverted) ? expression :
+                !expression.NeedsToBeConverted() ? expression :
                 type is null ? BindToNaturalType(expression, discardedDiagnostics, reportDefaultMissingType: false) :
                 GenerateConversionForAssignment(type, expression, discardedDiagnostics);
             discardedDiagnostics.Free();
@@ -804,7 +804,7 @@ private BoundExpression BindDeclarationVariablesForErrorRecovery(TypeWithAnnotat
 
                         // We will not check constraints at this point as this code path
                         // is failure-only and the caller is expected to produce a diagnostic.
-                        var tupleType = TupleTypeSymbol.Create(
+                        var tupleType = NamedTypeSymbol.CreateTuple(
                             locationOpt: null,
                             subExpressions.SelectAsArray(e => TypeWithAnnotations.Create(e.Type)),
                             elementLocations: default,
@@ -888,13 +888,13 @@ private BoundExpression BindTupleExpression(TupleExpressionSyntax node, Diagnost
             {
                 bool disallowInferredNames = this.Compilation.LanguageVersion.DisallowInferredTupleElementNames();
 
-                tupleTypeOpt = TupleTypeSymbol.Create(node.Location, elements, locations, elementNames,
+                tupleTypeOpt = NamedTypeSymbol.CreateTuple(node.Location, elements, locations, elementNames,
                     this.Compilation, syntax: node, diagnostics: diagnostics, shouldCheckConstraints: true,
                     includeNullability: false, errorPositions: disallowInferredNames ? inferredPositions : default(ImmutableArray<bool>));
             }
             else
             {
-                TupleTypeSymbol.VerifyTupleTypePresent(elements.Length, node, this.Compilation, diagnostics);
+                NamedTypeSymbol.VerifyTupleTypePresent(elements.Length, node, this.Compilation, diagnostics);
             }
 
             // Always track the inferred positions in the bound node, so that conversions don't produce a warning
@@ -1028,7 +1028,7 @@ private static string InferTupleElementName(SyntaxNode syntax)
             string name = syntax.TryGetInferredMemberName();
 
             // Reserved names are never candidates to be inferred names, at any position
-            if (name == null || TupleTypeSymbol.IsElementNameReserved(name) != -1)
+            if (name == null || NamedTypeSymbol.IsTupleElementNameReserved(name) != -1)
             {
                 return null;
             }
@@ -2269,7 +2269,7 @@ private void GenerateExplicitConversionErrors(
 
                         // If target is a tuple or compatible type with the same number of elements,
                         // report errors for tuple arguments that failed to convert, which would be more useful.
-                        if (targetType.TryGetElementTypesWithAnnotationsIfTupleOrCompatible(out targetElementTypesWithAnnotations) &&
+                        if (targetType.TryGetElementTypesWithAnnotationsIfTupleType(out targetElementTypesWithAnnotations) &&
                             targetElementTypesWithAnnotations.Length == tuple.Arguments.Length)
                         {
                             GenerateExplicitConversionErrorsForTupleLiteralArguments(diagnostics, tuple.Arguments, targetElementTypesWithAnnotations);

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

@@ -2084,7 +2084,7 @@ protected void GenerateImplicitConversionError(
 
                         // If target is a tuple or compatible type with the same number of elements,
                         // report errors for tuple arguments that failed to convert, which would be more useful.
-                        if (targetType.TryGetElementTypesWithAnnotationsIfTupleOrCompatible(out targetElementTypes) &&
+                        if (targetType.TryGetElementTypesWithAnnotationsIfTupleType(out targetElementTypes) &&
                             targetElementTypes.Length == tuple.Arguments.Length)
                         {
                             GenerateImplicitConversionErrorsForTupleLiteralArguments(diagnostics, tuple.Arguments, targetElementTypes);

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

@@ -655,7 +655,7 @@ private TypeSymbol BindTupleType(TupleTypeSyntax syntax, DiagnosticBag diagnosti
             }
 
             bool includeNullability = Compilation.IsFeatureEnabled(MessageID.IDS_FeatureNullableReferenceTypes);
-            return TupleTypeSymbol.Create(syntax.Location,
+            return NamedTypeSymbol.CreateTuple(syntax.Location,
                                           typesArray,
                                           locationsArray,
                                           elementNames == null ?
@@ -694,7 +694,7 @@ private static void CollectTupleFieldMemberName(string name, int elementIndex, i
 
         private static bool CheckTupleMemberName(string name, int index, SyntaxNodeOrToken syntax, DiagnosticBag diagnostics, PooledHashSet<string> uniqueFieldNames)
         {
-            int reserved = TupleTypeSymbol.IsElementNameReserved(name);
+            int reserved = NamedTypeSymbol.IsTupleElementNameReserved(name);
             if (reserved == 0)
             {
                 Error(diagnostics, ErrorCode.ERR_TupleReservedElementNameAnyPosition, syntax, name);
@@ -1263,11 +1263,9 @@ private NamedTypeSymbol ConstructNamedType(
             if (ShouldCheckConstraints && ConstraintsHelper.RequiresChecking(type))
             {
                 bool includeNullability = Compilation.IsFeatureEnabled(MessageID.IDS_FeatureNullableReferenceTypes);
-                type.CheckConstraintsForNonTuple(this.Conversions, includeNullability, typeSyntax, typeArgumentsSyntax, this.Compilation, basesBeingResolved, diagnostics);
+                type.CheckConstraintsForNamedType(this.Conversions, includeNullability, typeSyntax, typeArgumentsSyntax, this.Compilation, basesBeingResolved, diagnostics);
             }
 
-            type = (NamedTypeSymbol)TupleTypeSymbol.TransformToTupleIfCompatible(type);
-
             return type;
         }
 

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

@@ -394,7 +394,7 @@ private TypeSymbol MakeConvertedType(ImmutableArray<TypeSymbol> convertedTypes,
 
             ImmutableArray<Location> elementLocations = elements.SelectAsArray(e => e.Syntax.Location);
 
-            var tuple = TupleTypeSymbol.Create(locationOpt: null,
+            var tuple = NamedTypeSymbol.CreateTuple(locationOpt: null,
                 elementTypesWithAnnotations: convertedTypes.SelectAsArray(t => TypeWithAnnotations.Create(t)),
                 elementLocations, elementNames: names, compilation,
                 shouldCheckConstraints: true, includeNullability: false, errorPositions: default, syntax, diagnostics);

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

@@ -287,11 +287,6 @@ private static bool IsMemberAccessible(
 
             failedThroughTypeCheck = false;
 
-            if (containingType.IsTupleType)
-            {
-                containingType = containingType.TupleUnderlyingType;
-            }
-
             // easy case - members of containing type are accessible.
             if ((object)containingType == (object)within)
             {

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

@@ -2011,12 +2011,12 @@ private Conversion GetTupleLiteralConversion(
             var arguments = source.Arguments;
 
             // check if the type is actually compatible type for a tuple of given cardinality
-            if (!destination.IsTupleOrCompatibleWithTupleOfCardinality(arguments.Length))
+            if (!destination.IsTupleTypeOfCardinality(arguments.Length))
             {
                 return Conversion.NoConversion;
             }
 
-            var targetElementTypes = destination.GetElementTypesOfTupleOrCompatible();
+            var targetElementTypes = destination.TupleElementTypesWithAnnotations;
             Debug.Assert(arguments.Length == targetElementTypes.Length);
 
             // check arguments against flattened list of target element types 
@@ -2084,8 +2084,8 @@ private Conversion ClassifyTupleConversion(
             ImmutableArray<TypeWithAnnotations> sourceTypes;
             ImmutableArray<TypeWithAnnotations> destTypes;
 
-            if (!source.TryGetElementTypesWithAnnotationsIfTupleOrCompatible(out sourceTypes) ||
-                !destination.TryGetElementTypesWithAnnotationsIfTupleOrCompatible(out destTypes) ||
+            if (!source.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) ||
+                !destination.TryGetElementTypesWithAnnotationsIfTupleType(out destTypes) ||
                 sourceTypes.Length != destTypes.Length)
             {
                 return Conversion.NoConversion;
@@ -2790,7 +2790,6 @@ static bool isTypeIEquatable(NamedTypeSymbol type)
                     TypeParameters: { Length: 1 }
                 };
             }
-
         }
 
         // Spec 6.1.10

src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MethodTypeInference.cs

@@ -605,13 +605,13 @@ private bool MakeExplicitParameterTypeInferences(Binder binder, BoundTupleLitera
             var sourceArguments = argument.Arguments;
 
             // check if the type is actually compatible type for a tuple of given cardinality
-            if (!destination.IsTupleOrCompatibleWithTupleOfCardinality(sourceArguments.Length))
+            if (!destination.IsTupleTypeOfCardinality(sourceArguments.Length))
             {
                 // target is not a tuple of appropriate shape
                 return false;
             }
 
-            var destTypes = destination.GetElementTypesOfTupleOrCompatible();
+            var destTypes = destination.TupleElementTypesWithAnnotations;
             Debug.Assert(sourceArguments.Length == destTypes.Length);
 
             // NOTE: we are losing tuple element names when recursing into argument expressions.
@@ -778,12 +778,12 @@ private void MakeOutputTypeInferences(Binder binder, BoundTupleLiteral argument,
             var sourceArguments = argument.Arguments;
 
             // check if the type is actually compatible type for a tuple of given cardinality
-            if (!destination.IsTupleOrCompatibleWithTupleOfCardinality(sourceArguments.Length))
+            if (!destination.IsTupleTypeOfCardinality(sourceArguments.Length))
             {
                 return;
             }
 
-            var destTypes = destination.GetElementTypesOfTupleOrCompatible();
+            var destTypes = destination.TupleElementTypesWithAnnotations;
             Debug.Assert(sourceArguments.Length == destTypes.Length);
 
             for (int i = 0; i < sourceArguments.Length; i++)
@@ -1561,8 +1561,8 @@ private bool LowerBoundTupleInference(TypeWithAnnotations source, TypeWithAnnota
             ImmutableArray<TypeWithAnnotations> sourceTypes;
             ImmutableArray<TypeWithAnnotations> targetTypes;
 
-            if (!source.Type.TryGetElementTypesWithAnnotationsIfTupleOrCompatible(out sourceTypes) ||
-                !target.Type.TryGetElementTypesWithAnnotationsIfTupleOrCompatible(out targetTypes) ||
+            if (!source.Type.TryGetElementTypesWithAnnotationsIfTupleType(out sourceTypes) ||
+                !target.Type.TryGetElementTypesWithAnnotationsIfTupleType(out targetTypes) ||
                 sourceTypes.Length != targetTypes.Length)
             {
                 return false;
@@ -1585,13 +1585,13 @@ private bool ExactConstructedInference(TypeWithAnnotations source, TypeWithAnnot
             // SPEC:   type C<U1...Uk> then an exact inference 
             // SPEC:   is made from each Ui to the corresponding Vi.
 
-            var namedSource = source.Type.TupleUnderlyingTypeOrSelf() as NamedTypeSymbol;
+            var namedSource = source.Type as NamedTypeSymbol;
             if ((object)namedSource == null)
             {
                 return false;
             }
 
-            var namedTarget = target.Type.TupleUnderlyingTypeOrSelf() as NamedTypeSymbol;
+            var namedTarget = target.Type as NamedTypeSymbol;
             if ((object)namedTarget == null)
             {
                 return false;
@@ -1824,9 +1824,6 @@ private bool LowerBoundConstructedInference(TypeSymbol source, TypeSymbol target
             Debug.Assert((object)source != null);
             Debug.Assert((object)target != null);
 
-            source = source.TupleUnderlyingTypeOrSelf();
-            target = target.TupleUnderlyingTypeOrSelf();
-
             var constructedTarget = target as NamedTypeSymbol;
             if ((object)constructedTarget == null)
             {
@@ -2174,8 +2171,8 @@ private bool UpperBoundConstructedInference(TypeWithAnnotations sourceWithAnnota
         {
             Debug.Assert(sourceWithAnnotations.HasType);
             Debug.Assert(targetWithAnnotations.HasType);
-            var source = sourceWithAnnotations.Type.TupleUnderlyingTypeOrSelf();
-            var target = targetWithAnnotations.Type.TupleUnderlyingTypeOrSelf();
+            var source = sourceWithAnnotations.Type;
+            var target = targetWithAnnotations.Type;
 
             var constructedSource = source as NamedTypeSymbol;
             if ((object)constructedSource == null)