Confirm dead code removal in IsReplaceableByVar was ok

[jcouv]

I commented out a block of code below and then removed it without any test breaks. I still have some doubt whether this is a case of missing test or that code was truly unused.

        private static bool IsReplaceableByVar(
            this TypeSyntax simpleName,
            SemanticModel semanticModel,
            out TypeSyntax replacementNode,
            out TextSpan issueSpan,
            OptionSet optionSet,
            CancellationToken cancellationToken)
        {
            replacementNode = null;
            issueSpan = default(TextSpan);

            if (!optionSet.GetOption(SimplificationOptions.PreferImplicitTypeInLocalDeclaration))
            {
                return false;
            }

            // If it is already var
            if (simpleName.IsVar)
            {
                return false;
            }

            var candidateReplacementNode = SyntaxFactory.IdentifierName("var")
                                            .WithLeadingTrivia(simpleName.GetLeadingTrivia())
                                            .WithTrailingTrivia(simpleName.GetTrailingTrivia());
            var candidateIssueSpan = simpleName.Span;

            // If there exists a Type called var , fail.
            var checkSymbol = semanticModel.GetSpeculativeSymbolInfo(simpleName.SpanStart, candidateReplacementNode, SpeculativeBindingOption.BindAsTypeOrNamespace).Symbol;
            if (checkSymbol != null && checkSymbol.IsKind(SymbolKind.NamedType) && ((INamedTypeSymbol)checkSymbol).TypeKind == TypeKind.Class && checkSymbol.Name == "var")
            {
                return false;
            }

            // If the simpleName is the type of the Variable Declaration Syntax belonging to LocalDeclaration, For Statement or Using statement
            if (simpleName.IsParentKind(SyntaxKind.VariableDeclaration) &&
                ((VariableDeclarationSyntax)simpleName.Parent).Type == simpleName &&
                simpleName.Parent.Parent.IsKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.ForStatement, SyntaxKind.UsingStatement))
            {
                if (simpleName.Parent.IsParentKind(SyntaxKind.LocalDeclarationStatement) &&
                    ((LocalDeclarationStatementSyntax)simpleName.Parent.Parent).Modifiers.Any(n => n.Kind() == SyntaxKind.ConstKeyword))
                {
                    return false;
                }

                var variableDeclaration = (VariableDeclarationSyntax)simpleName.Parent;

                // Check the Initialized Value to see if it is allowed to be in the Var initialization
                if (variableDeclaration.Variables.Count != 1 ||
                    !variableDeclaration.Variables.Single().Initializer.IsKind(SyntaxKind.EqualsValueClause))
                {
                    return false;
                }

                var variable = variableDeclaration.Variables.Single();
                var initializer = variable.Initializer;
                var identifier = variable.Identifier;

                if (EqualsValueClauseNotSuitableForVar(identifier, simpleName, initializer, semanticModel, cancellationToken))
                {
                    return false;
                }

                replacementNode = candidateReplacementNode;
                issueSpan = candidateIssueSpan;
                return true;
            }

            if (simpleName.IsParentKind(SyntaxKind.ForEachStatement) &&
                ((ForEachStatementSyntax)simpleName.Parent).Type == simpleName)
            {
                replacementNode = candidateReplacementNode;
                issueSpan = candidateIssueSpan;
                return true;
            }

            //if (simpleName.IsParentKind(SyntaxKind.TypedVariableComponent))
            //{
            //    replacementNode = candidateReplacementNode;
            //    issueSpan = candidateIssueSpan;
            //    return true;
            //}
            // TODO REVIEW Are we lacking tests? It seems this code should be needed for DeclarationExpression

            return false;
        }

[jcouv]

@CyrusNajmabadi This is a small question left from PR #14871. Do you have thoughts (was this code needed)?

[CyrusNajmabadi]

I can look later tonight!

[CyrusNajmabadi]

Looks like we've had this code forever. @dpoeschl @DustinCampbell Do you know what this code is for? Apperantly, it's not called at all, so it seems like it's safe to remove.

[CyrusNajmabadi]

My mistake. I thought you meant hte entire function wasn't necessary. You just meant the part you commented out. That bit seems to have been added by @gafter in dbe4fb5. So he's probably best to determine why it's there and if it's needed.

[gafter]

I believe I added that code when I overhauled the syntax model around deconstruction and added the concept of components. Components were since removed from the syntax model, and were replaced by declaration expressions. I expect the code can safely be removed.

[jcouv]

Thanks!
I'll go ahead and close.