Merge pull request #15501 from AlekseyTs/Issue14881

Address issues with SemanticModel behavior around TupleElementSyntax.

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

@@ -432,16 +432,16 @@ private TypeSymbol BindTupleType(TupleTypeSyntax syntax, DiagnosticBag diagnosti
                 }
 
                 string name =  null;
-                IdentifierNameSyntax nameSyntax = argumentSyntax.Name;
+                SyntaxToken nameToken = argumentSyntax.Identifier;
 
-                if (nameSyntax != null)
+                if (nameToken.Kind() == SyntaxKind.IdentifierToken)
                 {
-                    name = nameSyntax.Identifier.ValueText;
+                    name = nameToken.ValueText;
 
                     // validate name if we have one
                     hasExplicitNames = true;
-                    CheckTupleMemberName(name, i, nameSyntax, diagnostics, uniqueFieldNames);
-                    locations.Add(nameSyntax.Location);
+                    CheckTupleMemberName(name, i, nameToken, diagnostics, uniqueFieldNames);
+                    locations.Add(nameToken.GetLocation());
                 }
                 else
                 {
@@ -513,7 +513,7 @@ private static void CollectTupleFieldMemberNames(string name, int position, int
             }
         }
 
-        private static bool CheckTupleMemberName(string name, int index, CSharpSyntaxNode syntax, DiagnosticBag diagnostics, PooledHashSet<string> uniqueFieldNames)
+        private static bool CheckTupleMemberName(string name, int index, SyntaxNodeOrToken syntax, DiagnosticBag diagnostics, PooledHashSet<string> uniqueFieldNames)
         {
             int reserved = TupleTypeSymbol.IsElementNameReserved(name);
             if (reserved == 0)

src/Compilers/CSharp/Portable/CSharpExtensions.cs

@@ -1233,6 +1233,15 @@ public static ISymbol GetDeclaredSymbol(this SemanticModel semanticModel, Variab
             return csmodel?.GetDeclaredSymbol(declarationSyntax, cancellationToken);
         }
 
+        /// <summary>
+        /// Given a tuple element syntax, get the corresponding symbol.
+        /// </summary>
+        public static ISymbol GetDeclaredSymbol(this SemanticModel semanticModel, TupleElementSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var csmodel = semanticModel as CSharpSemanticModel;
+            return csmodel?.GetDeclaredSymbol(declarationSyntax, cancellationToken);
+        }
+
         /// <summary>
         /// Given a labeled statement syntax, get the corresponding label symbol.
         /// </summary>

src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs

@@ -4602,6 +4602,8 @@ protected sealed override ISymbol GetDeclaredSymbolCore(SyntaxNode declaration,
                     return this.GetDeclaredSymbol((VariableDeclaratorSyntax)node, cancellationToken);
                 case SyntaxKind.SingleVariableDesignation:
                     return this.GetDeclaredSymbol((SingleVariableDesignationSyntax)node, cancellationToken);
+                case SyntaxKind.TupleElement:
+                    return this.GetDeclaredSymbol((TupleElementSyntax)node, cancellationToken);
                 case SyntaxKind.NamespaceDeclaration:
                     return this.GetDeclaredSymbol((NamespaceDeclarationSyntax)node, cancellationToken);
                 case SyntaxKind.Parameter:
@@ -4629,6 +4631,25 @@ protected sealed override ISymbol GetDeclaredSymbolCore(SyntaxNode declaration,
             return null;
         }
 
+        /// <summary>
+        /// Given a tuple element syntax, get the corresponding symbol.
+        /// </summary>
+        /// <param name="declarationSyntax">The syntax node that declares a tuple element.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The symbol that was declared.</returns>
+        public ISymbol GetDeclaredSymbol(TupleElementSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            CheckSyntaxNode(declarationSyntax);
+
+            var tupleTypeSyntax = declarationSyntax.Parent as TupleTypeSyntax;
+            if (tupleTypeSyntax != null)
+            {
+                return (GetSymbolInfo(tupleTypeSyntax).Symbol as TupleTypeSymbol)?.TupleElements.ElementAtOrDefault(tupleTypeSyntax.Elements.IndexOf(declarationSyntax));
+            }
+
+            return null;
+        }
+
         protected sealed override ImmutableArray<ISymbol> GetDeclaredSymbolsCore(SyntaxNode declaration, CancellationToken cancellationToken = default(CancellationToken))
         {
             cancellationToken.ThrowIfCancellationRequested();

src/Compilers/CSharp/Portable/GlobalSuppressions.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.
+
 // This file is used by Code Analysis to maintain SuppressMessage 
 // attributes that are applied to this project.
 // Project-level suppressions either have no target or are given 
@@ -18,6 +19,7 @@
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "<Pending>", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.EventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax)~Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "<Pending>", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax,System.Threading.CancellationToken)~Microsoft.CodeAnalysis.ILocalSymbol")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "<Pending>", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax,System.Threading.CancellationToken)~Microsoft.CodeAnalysis.ISymbol")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "<Pending>", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax,System.Threading.CancellationToken)~Microsoft.CodeAnalysis.ISymbol")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "<Pending>", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableComponent(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableComponentSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableComponentSyntax")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "<Pending>", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedVariableDesignation(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax")]
 

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -6647,11 +6647,11 @@ private TupleTypeSyntax ParseTupleType()
         private TupleElementSyntax ParseTupleElement()
         {
             var type = ParseType();
-            IdentifierNameSyntax name = null;
+            SyntaxToken name = null;
 
-            if (CurrentToken.Kind == SyntaxKind.IdentifierToken)
+            if (IsTrueIdentifier())
             {
-                name = ParseIdentifierName();
+                name = this.ParseIdentifierToken();
             }
 
             return _syntaxFactory.TupleElement(type, name);

src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt

@@ -127,10 +127,10 @@ Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.Update(Microsoft.Code
 Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax.WithThrowKeyword(Microsoft.CodeAnalysis.SyntaxToken throwKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
-Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithIdentifier(Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.Update(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax.AddArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
@@ -255,6 +255,7 @@ override Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept<TResult>(Mi
 override Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
 override Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax designationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
+static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetForEachStatementInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax forEachStatement) -> Microsoft.CodeAnalysis.CSharp.ForEachStatementInfo
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AccessorDeclaration(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body) -> Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax
@@ -296,7 +297,7 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SingleVariableDesignation(Mic
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ThrowExpression(Microsoft.CodeAnalysis.SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression) -> Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
-static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
+static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleExpression(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.TupleType(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax> elements = default(Microsoft.CodeAnalysis.SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax>)) -> Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax

src/Compilers/CSharp/Portable/Syntax/Syntax.xml

@@ -271,11 +271,11 @@
         <summary>Gets the type of the tuple element.</summary>
       </PropertyComment>
     </Field>
-    <Field Name="Name" Type="IdentifierNameSyntax" Optional="true">
+    <Field Name="Identifier" Type="SyntaxToken" Optional="true">
       <PropertyComment>
         <summary>Gets the name of the tuple element.</summary>
       </PropertyComment>
-      <Kind Name="IdentifierName"/>
+      <Kind Name="IdentifierToken"/>
     </Field>
   </Node>
   <Node Name="OmittedTypeArgumentSyntax" Base="TypeSyntax">

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs

@@ -3241,7 +3241,7 @@ static void Main()
             Assert.True(mFirst.GetAttributes().IsEmpty);
             Assert.Null(mFirst.GetUseSiteDiagnostic());
             Assert.False(mFirst.Locations.IsEmpty);
-            Assert.Equal("first", mFirst.DeclaringSyntaxReferences.Single().GetSyntax().ToString());
+            Assert.Equal("T1 first", mFirst.DeclaringSyntaxReferences.Single().GetSyntax().ToString());
             Assert.False(mFirst.IsImplicitlyDeclared);
             Assert.Null(mFirst.TypeLayoutOffset);
 
@@ -8837,7 +8837,7 @@ static void Main()
             Assert.True(m2a2.GetAttributes().IsEmpty);
             Assert.Null(m2a2.GetUseSiteDiagnostic());
             Assert.False(m2a2.Locations.IsEmpty);
-            Assert.Equal("a2", m2a2.DeclaringSyntaxReferences.Single().GetSyntax().ToString());
+            Assert.Equal("int a2", m2a2.DeclaringSyntaxReferences.Single().GetSyntax().ToString());
             Assert.Equal("Item1", m2a2.TupleUnderlyingField.Name);
             Assert.False(m2a2.IsImplicitlyDeclared);
             Assert.Null(m2a2.TypeLayoutOffset);
@@ -9264,7 +9264,7 @@ static void Main()
             Assert.True(m4h4.GetAttributes().IsEmpty);
             Assert.Null(m4h4.GetUseSiteDiagnostic());
             Assert.False(m4h4.Locations.IsEmpty);
-            Assert.Equal("h4", m4h4.DeclaringSyntaxReferences.Single().GetSyntax().ToString());
+            Assert.Equal("int h4", m4h4.DeclaringSyntaxReferences.Single().GetSyntax().ToString());
             Assert.Equal("Item1", m4h4.TupleUnderlyingField.Name);
             Assert.False(m4h4.IsImplicitlyDeclared);
             Assert.Null(m4h4.TypeLayoutOffset);
@@ -9494,7 +9494,7 @@ static void Main()
             Assert.True(m5Item8.GetAttributes().IsEmpty);
             Assert.Null(m5Item8.GetUseSiteDiagnostic());
             Assert.False(m5Item8.Locations.IsEmpty);
-            Assert.Equal("Item8", m5Item8.DeclaringSyntaxReferences.Single().GetSyntax().ToString());
+            Assert.Equal("int Item8", m5Item8.DeclaringSyntaxReferences.Single().GetSyntax().ToString());
             Assert.Equal("Item1", m5Item8.TupleUnderlyingField.Name);
             Assert.False(m5Item8.IsImplicitlyDeclared);
             Assert.Null(m5Item8.TypeLayoutOffset);
@@ -20258,5 +20258,68 @@ public struct S { }
                 Diagnostic(ErrorCode.WRN_UnreferencedVarAssg, "t14").WithArguments("t14").WithLocation(32, 21)
                 );
         }
+
+        [Fact]
+        [WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")]
+        [WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")]
+        public void TupleElementVsLocal()
+        {
+            var source = @"
+using System;
+
+static class Program
+{
+    static void Main()
+    {
+        (int elem1, int elem2) tuple;
+        int elem2;
+
+        tuple = (5, 6);
+        tuple.elem2 = 23;
+        elem2 = 10;
+
+        Console.WriteLine(tuple.elem2);
+        Console.WriteLine(elem2);
+    }
+}
+";
+
+            var compilation = CreateCompilationWithMscorlib(source, references: new[] { ValueTupleRef, SystemRuntimeFacadeRef });
+
+            compilation.VerifyDiagnostics();
+
+            var tree = compilation.SyntaxTrees.First();
+            var model = compilation.GetSemanticModel(tree);
+            var nodes = tree.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "elem2").ToArray();
+
+            Assert.Equal(4, nodes.Length);
+
+            Assert.Equal("tuple.elem2 = 23", nodes[0].Parent.Parent.ToString());
+            Assert.Equal("System.Int32 (System.Int32 elem1, System.Int32 elem2).elem2", model.GetSymbolInfo(nodes[0]).Symbol.ToTestDisplayString());
+
+            Assert.Equal("elem2 = 10", nodes[1].Parent.ToString());
+            Assert.Equal("System.Int32 elem2", model.GetSymbolInfo(nodes[1]).Symbol.ToTestDisplayString());
+
+            Assert.Equal("(tuple.elem2)", nodes[2].Parent.Parent.Parent.ToString());
+            Assert.Equal("System.Int32 (System.Int32 elem1, System.Int32 elem2).elem2", model.GetSymbolInfo(nodes[2]).Symbol.ToTestDisplayString());
+
+            Assert.Equal("(elem2)", nodes[3].Parent.Parent.ToString());
+            Assert.Equal("System.Int32 elem2", model.GetSymbolInfo(nodes[3]).Symbol.ToTestDisplayString());
+
+            var type = tree.GetRoot().DescendantNodes().OfType<TupleTypeSyntax>().Single();
+
+            var symbolInfo = model.GetSymbolInfo(type);
+            Assert.Equal("(System.Int32 elem1, System.Int32 elem2)", symbolInfo.Symbol.ToTestDisplayString());
+
+            var typeInfo = model.GetTypeInfo(type);
+            Assert.Equal("(System.Int32 elem1, System.Int32 elem2)", typeInfo.Type.ToTestDisplayString());
+
+            Assert.Same(symbolInfo.Symbol, typeInfo.Type);
+
+            Assert.Equal("System.Int32 (System.Int32 elem1, System.Int32 elem2).elem1", model.GetDeclaredSymbol(type.Elements.First()).ToTestDisplayString());
+            Assert.Equal("System.Int32 (System.Int32 elem1, System.Int32 elem2).elem2", model.GetDeclaredSymbol(type.Elements.Last()).ToTestDisplayString());
+            Assert.Equal("System.Int32 (System.Int32 elem1, System.Int32 elem2).elem1", model.GetDeclaredSymbol((SyntaxNode)type.Elements.First()).ToTestDisplayString());
+            Assert.Equal("System.Int32 (System.Int32 elem1, System.Int32 elem2).elem2", model.GetDeclaredSymbol((SyntaxNode)type.Elements.Last()).ToTestDisplayString());
+        }
     }
 }
\ No newline at end of file

src/Compilers/CSharp/Test/Syntax/Parsing/DeconstructionTests.cs

@@ -149,10 +149,7 @@ void Foo()
                                             {
                                                 N(SyntaxKind.IdentifierToken);
                                             }
-                                            N(SyntaxKind.IdentifierName);
-                                            {
-                                                N(SyntaxKind.IdentifierToken);
-                                            }
+                                            N(SyntaxKind.IdentifierToken);
                                         }
                                         N(SyntaxKind.CommaToken);
                                         N(SyntaxKind.TupleElement);
@@ -161,10 +158,7 @@ void Foo()
                                             {
                                                 N(SyntaxKind.IdentifierToken);
                                             }
-                                            N(SyntaxKind.IdentifierName);
-                                            {
-                                                N(SyntaxKind.IdentifierToken);
-                                            }
+                                            N(SyntaxKind.IdentifierToken);
                                         }
                                         N(SyntaxKind.CloseParenToken);
                                     }

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

@@ -222,7 +222,7 @@ public void TestLocalDeclarationStatementWithTuple()
             var tt = (TupleTypeSyntax)ds.Declaration.Type;
 
             Assert.Equal(SyntaxKind.PredefinedType, tt.Elements[0].Type.Kind());
-            Assert.Null(tt.Elements[1].Name);
+            Assert.Equal(SyntaxKind.None, tt.Elements[1].Identifier.Kind());
             Assert.Equal(2, tt.Elements.Count);
 
             Assert.NotNull(ds.Declaration.Variables[0].Identifier);
@@ -255,7 +255,7 @@ public void TestLocalDeclarationStatementWithNamedTuple()
             var tt = (TupleTypeSyntax)ds.Declaration.Type;
 
             Assert.Equal(SyntaxKind.IdentifierName, tt.Elements[0].Type.Kind());
-            Assert.Equal("y", tt.Elements[1].Name.ToString());
+            Assert.Equal("y", tt.Elements[1].Identifier.ToString());
             Assert.Equal(2, tt.Elements.Count);
 
 
@@ -263,7 +263,7 @@ public void TestLocalDeclarationStatementWithNamedTuple()
 
             Assert.Equal("(U k, V l, W m)", tt.ToString());
             Assert.Equal(SyntaxKind.IdentifierName, tt.Elements[0].Type.Kind());
-            Assert.Equal("l", tt.Elements[1].Name.ToString());
+            Assert.Equal("l", tt.Elements[1].Identifier.ToString());
             Assert.Equal(3, tt.Elements.Count);
 
             Assert.NotNull(ds.Declaration.Variables[0].Identifier);

src/Compilers/CSharp/Test/Syntax/Parsing/ValueTupleTests.cs

@@ -362,10 +362,7 @@ class C
                                                         {
                                                             N(SyntaxKind.StringKeyword);
                                                         }
-                                                        N(SyntaxKind.IdentifierName);
-                                                        {
-                                                            N(SyntaxKind.IdentifierToken);
-                                                        }
+                                                        N(SyntaxKind.IdentifierToken);
                                                     }
                                                     N(SyntaxKind.CommaToken);
                                                     N(SyntaxKind.TupleElement);
@@ -399,10 +396,7 @@ class C
                                                         {
                                                             N(SyntaxKind.IntKeyword);
                                                         }
-                                                        N(SyntaxKind.IdentifierName);
-                                                        {
-                                                            N(SyntaxKind.IdentifierToken);
-                                                        }
+                                                        N(SyntaxKind.IdentifierToken);
                                                     }
                                                     N(SyntaxKind.CloseParenToken);
                                                 }

src/Compilers/VisualBasic/Portable/BasicCodeAnalysis.vbproj

@@ -396,6 +396,7 @@
     <Compile Include="Errors\VBDiagnostic.vb" />
     <Compile Include="GlobalImport.ImportDiagnosticInfo.vb" />
     <Compile Include="GlobalImport.vb" />
+    <Compile Include="GlobalSuppressions.vb" />
     <Compile Include="LanguageVersion.vb" />
     <Compile Include="Locations\EmbeddedTreeLocation.vb" />
     <Compile Include="Locations\LocationExtensions.vb" />
@@ -990,4 +991,4 @@
   </ItemGroup>
   <Import Project="..\BasicAnalyzerDriver\BasicAnalyzerDriver.projitems" Label="Shared" />
   <Import Project="..\..\..\..\build\Targets\Imports.targets" />
-</Project>
+</Project>
\ No newline at end of file

src/Compilers/VisualBasic/Portable/Binding/Binder_Expressions.vb

@@ -457,7 +457,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End If
         End Sub
 
-        Private Shared Function CheckTupleMemberName(name As String, index As Integer, syntax As VisualBasicSyntaxNode, diagnostics As DiagnosticBag, uniqueFieldNames As HashSet(Of String)) As Boolean
+        Private Shared Function CheckTupleMemberName(name As String, index As Integer, syntax As SyntaxNodeOrToken, diagnostics As DiagnosticBag, uniqueFieldNames As HashSet(Of String)) As Boolean
             Dim reserved As Integer = TupleTypeSymbol.IsElementNameReserved(name)
             If reserved = 0 Then
                 Binder.ReportDiagnostic(diagnostics, syntax, ERRID.ERR_TupleReservedElementNameAnyPosition, name)

src/Compilers/VisualBasic/Portable/Binding/Binder_Symbols.vb

@@ -707,7 +707,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
                     Dim argumentType As TypeSymbol = Nothing
                     Dim name As String = Nothing
-                    Dim nameSyntax As IdentifierNameSyntax = Nothing
+                    Dim nameSyntax As SyntaxToken = Nothing
 
                     If argumentSyntax.Kind = SyntaxKind.TypedTupleElement Then
                         Dim typedElement = DirectCast(argumentSyntax, TypedTupleElementSyntax)
@@ -716,9 +716,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     Else
                         Dim namedElement = DirectCast(argumentSyntax, NamedTupleElementSyntax)
                         nameSyntax = namedElement.Identifier
-                        name = nameSyntax.Identifier.GetIdentifierText()
+                        name = nameSyntax.GetIdentifierText()
 
-                        argumentType = binder.DecodeIdentifierType(nameSyntax.Identifier, namedElement.AsClause, getRequireTypeDiagnosticInfoFunc:=Nothing, diagBag:=diagnostics)
+                        argumentType = binder.DecodeIdentifierType(nameSyntax, namedElement.AsClause, getRequireTypeDiagnosticInfoFunc:=Nothing, diagBag:=diagnostics)
                     End If
 
                     types.Add(argumentType)
@@ -728,7 +728,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     End If
 
 
-                    If nameSyntax IsNot Nothing Then
+                    If nameSyntax.Kind() = SyntaxKind.IdentifierToken Then
                         ' validate name if we have one
                         hasExplicitNames = True
                         Binder.CheckTupleMemberName(name, i, nameSyntax, diagnostics, uniqueFieldNames)

src/Compilers/VisualBasic/Portable/Compilation/SemanticModel.vb

@@ -2398,6 +2398,24 @@ _Default:
             Return Nothing
         End Function
 
+        ''' <summary>
+        ''' Gets the corresponding symbol for a specified tuple element.
+        ''' </summary>
+        ''' <param name="elementSyntax">A TupleElementSyntax object.</param>
+        ''' <param name="cancellationToken">A cancellation token.</param>
+        ''' <returns>A symbol, for the specified element; otherwise Nothing. </returns>
+        Public Overloads Function GetDeclaredSymbol(elementSyntax As TupleElementSyntax, Optional cancellationToken As CancellationToken = Nothing) As ISymbol
+            CheckSyntaxNode(elementSyntax)
+
+            Dim tupleTypeSyntax = TryCast(elementSyntax.Parent, TupleTypeSyntax)
+
+            If tupleTypeSyntax IsNot Nothing Then
+                Return TryCast(GetSymbolInfo(tupleTypeSyntax).Symbol, TupleTypeSymbol)?.TupleElements.ElementAtOrDefault(tupleTypeSyntax.Elements.IndexOf(elementSyntax))
+            End If
+
+            Return Nothing
+        End Function
+
         ''' <summary>
         ''' Given an FieldInitializerSyntax, get the corresponding symbol of anonymous type property.
         ''' </summary>
@@ -3214,6 +3232,10 @@ _Default:
                 Case SyntaxKind.SimpleImportsClause
                     Return Me.GetDeclaredSymbol(DirectCast(node, SimpleImportsClauseSyntax), cancellationToken)
 
+                Case SyntaxKind.TypedTupleElement,
+                     SyntaxKind.NamedTupleElement
+                    Return Me.GetDeclaredSymbol(DirectCast(node, TupleElementSyntax), cancellationToken)
+
                 Case SyntaxKind.ModifiedIdentifier
                     Return Me.GetDeclaredSymbol(DirectCast(node, ModifiedIdentifierSyntax), cancellationToken)
 

src/Compilers/VisualBasic/Portable/GlobalSuppressions.vb

+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+' This file Is used by Code Analysis to maintain SuppressMessage 
+' attributes that are applied to this project.
+' Project-level suppressions either have no target Or are given 
+' a specific target And scoped to a namespace, type, member, etc.
+
+<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification:="<Pending>", Scope:="member", Target:="~M:Microsoft.CodeAnalysis.VisualBasic.VisualBasicExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleElementSyntax,System.Threading.CancellationToken)~Microsoft.CodeAnalysis.ISymbol")>

src/Compilers/VisualBasic/Portable/Parser/Parser.vb

@@ -2947,7 +2947,7 @@ checkNullable:
             Dim unexpected As GreenNode = Nothing
 
             Do
-                Dim identifierNameOpt As IdentifierNameSyntax = Nothing
+                Dim identifierNameOpt As IdentifierTokenSyntax = Nothing
                 Dim asKeywordOpt As KeywordSyntax = Nothing
 
                 ' if there is a type character or As, then this must be a name
@@ -2955,7 +2955,7 @@ checkNullable:
                         (DirectCast(CurrentToken, IdentifierTokenSyntax).TypeCharacter <> TypeCharacter.None OrElse
                         PeekNextToken().Kind = SyntaxKind.AsKeyword) Then
 
-                    identifierNameOpt = SyntaxFactory.IdentifierName(ParseIdentifier())
+                    identifierNameOpt = ParseIdentifier()
                     TryGetToken(SyntaxKind.AsKeyword, asKeywordOpt)
                 End If
 

src/Compilers/VisualBasic/Portable/PublicAPI.Unshipped.txt

@@ -8,10 +8,10 @@ Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.Latest = 2147483647 -> Micros
 Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic15 = 15 -> Microsoft.CodeAnalysis.VisualBasic.LanguageVersion
 Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
 Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax.AsClause() -> Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleAsClauseSyntax
-Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax.Identifier() -> Microsoft.CodeAnalysis.VisualBasic.Syntax.IdentifierNameSyntax
-Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax.Update(identifier As Microsoft.CodeAnalysis.VisualBasic.Syntax.IdentifierNameSyntax, asClause As Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleAsClauseSyntax) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
+Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax.Identifier() -> Microsoft.CodeAnalysis.SyntaxToken
+Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax.Update(identifier As Microsoft.CodeAnalysis.SyntaxToken, asClause As Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleAsClauseSyntax) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
 Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax.WithAsClause(asClause As Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleAsClauseSyntax) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
-Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax.WithIdentifier(identifier As Microsoft.CodeAnalysis.VisualBasic.Syntax.IdentifierNameSyntax) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
+Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax.WithIdentifier(identifier As Microsoft.CodeAnalysis.SyntaxToken) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
 Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleElementSyntax
 Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleExpressionSyntax
 Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleExpressionSyntax.AddArguments(ParamArray items As Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleArgumentSyntax()) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleExpressionSyntax
@@ -40,6 +40,7 @@ Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.TupleExpression = 788 -> Microsoft
 Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.TupleType = 789 -> Microsoft.CodeAnalysis.VisualBasic.SyntaxKind
 Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.TypedTupleElement = 790 -> Microsoft.CodeAnalysis.VisualBasic.SyntaxKind
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions.ParseOptions() -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions
+Microsoft.CodeAnalysis.VisualBasic.VisualBasicExtensions.GetDeclaredSymbol(semanticModel As Microsoft.CodeAnalysis.SemanticModel, elementSyntax As Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleElementSyntax, cancellationToken As System.Threading.CancellationToken = Nothing) -> Microsoft.CodeAnalysis.ISymbol
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions.New(languageVersion As Microsoft.CodeAnalysis.VisualBasic.LanguageVersion = Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.Default, documentationMode As Microsoft.CodeAnalysis.DocumentationMode = Microsoft.CodeAnalysis.DocumentationMode.Parse, kind As Microsoft.CodeAnalysis.SourceCodeKind = Microsoft.CodeAnalysis.SourceCodeKind.Regular, preprocessorSymbols As System.Collections.Generic.IEnumerable(Of System.Collections.Generic.KeyValuePair(Of String, Object)) = Nothing) -> Void
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions.SpecifiedLanguageVersion() -> Microsoft.CodeAnalysis.VisualBasic.LanguageVersion
 Overridable Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxVisitor(Of TResult).VisitNamedTupleElement(node As Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax) -> TResult
@@ -64,8 +65,9 @@ Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxRewriter.VisitName
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxRewriter.VisitTupleExpression(node As Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleExpressionSyntax) -> Microsoft.CodeAnalysis.SyntaxNode
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxRewriter.VisitTupleType(node As Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleTypeSyntax) -> Microsoft.CodeAnalysis.SyntaxNode
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxRewriter.VisitTypedTupleElement(node As Microsoft.CodeAnalysis.VisualBasic.Syntax.TypedTupleElementSyntax) -> Microsoft.CodeAnalysis.SyntaxNode
-Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.NamedTupleElement(identifier As Microsoft.CodeAnalysis.VisualBasic.Syntax.IdentifierNameSyntax) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
-Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.NamedTupleElement(identifier As Microsoft.CodeAnalysis.VisualBasic.Syntax.IdentifierNameSyntax, asClause As Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleAsClauseSyntax) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
+Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.NamedTupleElement(identifier As Microsoft.CodeAnalysis.SyntaxToken) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
+Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.NamedTupleElement(identifier As Microsoft.CodeAnalysis.SyntaxToken, asClause As Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleAsClauseSyntax) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
+Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.NamedTupleElement(identifier As String) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.NamedTupleElementSyntax
 Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.TupleExpression(ParamArray arguments As Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleArgumentSyntax()) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleExpressionSyntax
 Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.TupleExpression(arguments As Microsoft.CodeAnalysis.SeparatedSyntaxList(Of Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleArgumentSyntax)) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleExpressionSyntax
 Shared Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.TupleExpression(openParenToken As Microsoft.CodeAnalysis.SyntaxToken, arguments As Microsoft.CodeAnalysis.SeparatedSyntaxList(Of Microsoft.CodeAnalysis.VisualBasic.Syntax.SimpleArgumentSyntax), closeParenToken As Microsoft.CodeAnalysis.SyntaxToken) -> Microsoft.CodeAnalysis.VisualBasic.Syntax.TupleExpressionSyntax

src/Compilers/VisualBasic/Portable/Syntax/Syntax.xml

@@ -5112,7 +5112,7 @@ Unify Enum declarations with other block type declarations.
 
       <node-kind name="NamedTupleElement"></node-kind>
 
-      <child name="Identifier" kind="IdentifierName">
+      <child name="Identifier" kind="IdentifierToken">
         <description>The name of the element.</description>
       </child>
 

src/Compilers/VisualBasic/Portable/VisualBasicExtensions.vb

@@ -831,6 +831,23 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             End If
         End Function
 
+        ''' <summary>
+        ''' Gets the corresponding symbol for a specified tuple element.
+        ''' </summary>
+        ''' <param name="semanticModel">A source semantic model.</param>
+        ''' <param name="elementSyntax">A TupleElementSyntax object.</param>
+        ''' <param name="cancellationToken">A cancellation token.</param>
+        ''' <returns>A symbol, for the specified element; otherwise Nothing. </returns>
+        <Extension>
+        Public Function GetDeclaredSymbol(semanticModel As SemanticModel, elementSyntax As TupleElementSyntax, Optional cancellationToken As CancellationToken = Nothing) As ISymbol
+            Dim vbmodel = TryCast(semanticModel, VBSemanticModel)
+            If vbmodel IsNot Nothing Then
+                Return vbmodel.GetDeclaredSymbol(elementSyntax, cancellationToken)
+            Else
+                Return Nothing
+            End If
+        End Function
+
         ''' <summary>
         ''' Gets the corresponding PropertySymbol for a specified FieldInitializerSyntax.
         ''' </summary>

src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb

@@ -5566,7 +5566,7 @@ BC37267: Predefined type 'ValueTuple(Of ,)' is not defined or imported.
             Assert.True(mFirst.GetAttributes().IsEmpty)
             'Assert.Null(mFirst.GetUseSiteDiagnostic())
             Assert.False(mFirst.Locations.IsEmpty)
-            Assert.Equal("first", mFirst.DeclaringSyntaxReferences.Single().GetSyntax().ToString())
+            Assert.Equal("first As T1", mFirst.DeclaringSyntaxReferences.Single().GetSyntax().ToString())
             Assert.False(mFirst.IsImplicitlyDeclared)
             Assert.Null(mFirst.TypeLayoutOffset)
 
@@ -13552,7 +13552,7 @@ options:=TestOptions.DebugExe, additionalRefs:=s_valueTupleRefs)
             Assert.True(m2a2.GetAttributes().IsEmpty)
             Assert.Null(m2a2.GetUseSiteErrorInfo())
             Assert.False(m2a2.Locations.IsEmpty)
-            Assert.Equal("a2", m2a2.DeclaringSyntaxReferences.Single().GetSyntax().ToString())
+            Assert.Equal("a2 As Integer", m2a2.DeclaringSyntaxReferences.Single().GetSyntax().ToString())
             Assert.Equal("Item1", m2a2.TupleUnderlyingField.Name)
             Assert.False(m2a2.IsImplicitlyDeclared)
             Assert.Null(m2a2.TypeLayoutOffset)
@@ -14180,7 +14180,7 @@ options:=TestOptions.DebugExe, additionalRefs:=s_valueTupleRefs)
             Assert.True(m5Item8.GetAttributes().IsEmpty)
             Assert.Null(m5Item8.GetUseSiteErrorInfo())
             Assert.False(m5Item8.Locations.IsEmpty)
-            Assert.Equal("Item8", m5Item8.DeclaringSyntaxReferences.Single().GetSyntax().ToString())
+            Assert.Equal("Item8 As Integer", m5Item8.DeclaringSyntaxReferences.Single().GetSyntax().ToString())
             Assert.Equal("Item1", m5Item8.TupleUnderlyingField.Name)
             Assert.False(m5Item8.IsImplicitlyDeclared)
             Assert.Null(m5Item8.TypeLayoutOffset)
@@ -18107,6 +18107,69 @@ End Class
             AssertTheseDiagnostics(comp3)
         End Sub
 
+        <Fact()>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Sub TupleElementVsLocal()
+            Dim compilation = CreateCompilationWithMscorlibAndVBRuntime(
+<compilation>
+    <file name="a.vb"><![CDATA[
+Imports System
+Module C
+
+    Sub Main()
+        Dim tuple As (Integer, elem2 As Integer)
+        Dim elem2 As Integer
+
+        tuple = (5, 6)
+        tuple.elem2 = 23
+        elem2 = 10
+
+        Console.WriteLine(tuple.elem2)
+        Console.WriteLine(elem2)
+    End Sub
+End Module
+]]></file>
+</compilation>, additionalRefs:=s_valueTupleRefs)
+
+            compilation.AssertTheseDiagnostics()
+
+            Dim tree = compilation.SyntaxTrees.First()
+            Dim model = compilation.GetSemanticModel(tree)
+            Dim nodes = tree.GetRoot().DescendantNodes().OfType(Of IdentifierNameSyntax)().Where(Function(id) id.Identifier.ValueText = "elem2").ToArray()
+
+            Assert.Equal(4, nodes.Length)
+
+            Assert.Equal("tuple.elem2 = 23", nodes(0).Parent.Parent.ToString())
+            Assert.Equal("(System.Int32, elem2 As System.Int32).elem2 As System.Int32", model.GetSymbolInfo(nodes(0)).Symbol.ToTestDisplayString())
+
+            Assert.Equal("elem2 = 10", nodes(1).Parent.ToString())
+            Assert.Equal("elem2 As System.Int32", model.GetSymbolInfo(nodes(1)).Symbol.ToTestDisplayString())
+
+            Assert.Equal("(tuple.elem2)", nodes(2).Parent.Parent.Parent.ToString())
+            Assert.Equal("(System.Int32, elem2 As System.Int32).elem2 As System.Int32", model.GetSymbolInfo(nodes(2)).Symbol.ToTestDisplayString())
+
+            Assert.Equal("(elem2)", nodes(3).Parent.Parent.ToString())
+            Assert.Equal("elem2 As System.Int32", model.GetSymbolInfo(nodes(3)).Symbol.ToTestDisplayString())
+
+            Dim type = tree.GetRoot().DescendantNodes().OfType(Of TupleTypeSyntax)().Single()
+
+            Dim symbolInfo = model.GetSymbolInfo(type)
+            Assert.Equal("(System.Int32, elem2 As System.Int32)", symbolInfo.Symbol.ToTestDisplayString())
+
+            Dim typeInfo = model.GetTypeInfo(type)
+            Assert.Equal("(System.Int32, elem2 As System.Int32)", typeInfo.Type.ToTestDisplayString())
+
+            Assert.Same(symbolInfo.Symbol, typeInfo.Type)
+
+            Assert.Equal(SyntaxKind.TypedTupleElement, type.Elements.First().Kind())
+            Assert.Equal("(System.Int32, elem2 As System.Int32).Item1 As System.Int32", model.GetDeclaredSymbol(type.Elements.First()).ToTestDisplayString())
+            Assert.Equal(SyntaxKind.NamedTupleElement, type.Elements.Last().Kind())
+            Assert.Equal("(System.Int32, elem2 As System.Int32).elem2 As System.Int32", model.GetDeclaredSymbol(type.Elements.Last()).ToTestDisplayString())
+            Assert.Equal("(System.Int32, elem2 As System.Int32).Item1 As System.Int32", model.GetDeclaredSymbol(DirectCast(type.Elements.First(), SyntaxNode)).ToTestDisplayString())
+            Assert.Equal("(System.Int32, elem2 As System.Int32).elem2 As System.Int32", model.GetDeclaredSymbol(DirectCast(type.Elements.Last(), SyntaxNode)).ToTestDisplayString())
+        End Sub
+
     End Class
 
 End Namespace

src/EditorFeatures/Test2/FindReferences/FindReferencesTests.LocalSymbols.vb

@@ -291,5 +291,253 @@ End Module
         End Function
 #End Region
 
+        <WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Async Function TupleElementVsLocal_CS_01() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+using System;
+
+static class Program
+{
+    static void Main()
+    {
+        (int elem1, int elem2) tuple;
+        int {|Definition:$$elem2|};
+
+        tuple = (5, 6);
+        tuple.elem2 = 23;
+        [|elem2|] = 10;
+
+        Console.WriteLine(tuple.elem2);
+        Console.WriteLine([|elem2|]);
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input)
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Async Function TupleElementVsLocal_CS_02() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+using System;
+
+static class Program
+{
+    static void Main()
+    {
+        (int elem1, int elem2) tuple;
+        int {|Definition:elem2|};
+
+        tuple = (5, 6);
+        tuple.elem2 = 23;
+        [|elem2|] = 10;
+
+        Console.WriteLine(tuple.elem2);
+        Console.WriteLine([|$$elem2|]);
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input)
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Async Function TupleElementVsLocal_CS_03() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+using System;
+
+static class Program
+{
+    static void Main()
+    {
+        (int elem1, int {|Definition:$$elem2|}) tuple;
+        int elem2;
+
+        tuple = (5, 6);
+        tuple.[|elem2|] = 23;
+        elem2 = 10;
+
+        Console.WriteLine(tuple.[|elem2|]);
+        Console.WriteLine(elem2);
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input)
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Async Function TupleElementVsLocal_CS_04() As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+using System;
+
+static class Program
+{
+    static void Main()
+    {
+        (int elem1, int {|Definition:elem2|}) tuple;
+        int elem2;
+
+        tuple = (5, 6);
+        tuple.[|elem2|] = 23;
+        elem2 = 10;
+
+        Console.WriteLine(tuple.[|$$elem2|]);
+        Console.WriteLine(elem2);
+    }
+}
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input)
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Async Function TupleElementVsLocal_VB_01() As Task
+            Dim input =
+<Workspace>
+    <Project Language="Visual Basic" CommonReferences="true">
+        <Document>
+Imports System
+Module C
+
+    Sub Main()
+        Dim tuple As (elem1 As Integer, elem2 As Integer)
+        Dim {|Definition:$$elem2|} As Integer
+
+        tuple = (5, 6)
+        tuple.elem2 = 23
+        [|elem2|] = 10
+
+        Console.WriteLine(tuple.elem2)
+        Console.WriteLine([|elem2|])
+    End Sub
+End Module
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input)
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Async Function TupleElementVsLocal_VB_02() As Task
+            Dim input =
+<Workspace>
+    <Project Language="Visual Basic" CommonReferences="true">
+        <Document>
+Imports System
+Module C
+
+    Sub Main()
+        Dim tuple As (elem1 As Integer, elem2 As Integer)
+        Dim {|Definition:elem2|} As Integer
+
+        tuple = (5, 6)
+        tuple.elem2 = 23
+        [|elem2|] = 10
+
+        Console.WriteLine(tuple.elem2)
+        Console.WriteLine([|$$elem2|])
+    End Sub
+End Module
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input)
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Async Function TupleElementVsLocal_VB_03() As Task
+            Dim input =
+<Workspace>
+    <Project Language="Visual Basic" CommonReferences="true">
+        <Document>
+Imports System
+Module C
+
+    Sub Main()
+        Dim tuple As (elem1 As Integer, {|Definition:$$elem2|} As Integer)
+        Dim elem2 As Integer
+
+        tuple = (5, 6)
+        tuple.[|elem2|] = 23
+        elem2 = 10
+
+        Console.WriteLine(tuple.[|elem2|])
+        Console.WriteLine(elem2)
+    End Sub
+End Module
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input)
+        End Function
+
+        <WpfFact, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        <Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)>
+        <WorkItem(14881, "https://github.com/dotnet/roslyn/issues/14881")>
+        <WorkItem(15476, "https://github.com/dotnet/roslyn/issues/15476")>
+        Public Async Function TupleElementVsLocal_VB_04() As Task
+            Dim input =
+<Workspace>
+    <Project Language="Visual Basic" CommonReferences="true">
+        <Document>
+Imports System
+Module C
+
+    Sub Main()
+        Dim tuple As (elem1 As Integer, {|Definition:elem2|} As Integer)
+        Dim elem2 As Integer
+
+        tuple = (5, 6)
+        tuple.[|elem2|] = 23
+        elem2 = 10
+
+        Console.WriteLine(tuple.[|$$elem2|])
+        Console.WriteLine(elem2)
+    End Sub
+End Module
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input)
+        End Function
+
     End Class
 End Namespace

src/Workspaces/CSharp/Portable/Extensions/ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs

@@ -170,7 +170,7 @@ private TupleTypeSyntax CreateTupleTypeSyntax(INamedTypeSymbol symbol)
 
                 foreach (var element in symbol.TupleElements)
                 {   
-                    var name = element.IsImplicitlyDeclared ? null: SyntaxFactory.IdentifierName(element.Name);
+                    var name = element.IsImplicitlyDeclared ? default(SyntaxToken) : SyntaxFactory.Identifier(element.Name);
                     list = list.Add(SyntaxFactory.TupleElement(element.Type.GenerateTypeSyntax(), name));
                 }
 

src/Workspaces/VisualBasic/Portable/Extensions/TypeSyntaxGeneratorVisitor.vb

@@ -129,7 +129,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Extensions
             Return SyntaxFactory.TupleType(SyntaxFactory.SeparatedList(
                 elements.Select(Function(element) If(Not element.IsImplicitlyDeclared,
                                                         SyntaxFactory.NamedTupleElement(
-                                                                        SyntaxFactory.IdentifierName(element.Name),
+                                                                        SyntaxFactory.Identifier(element.Name),
                                                                         SyntaxFactory.SimpleAsClause(
                                                                                     SyntaxFactory.Token(SyntaxKind.AsKeyword),
                                                                                     Nothing,