public static Dictionary CreateNodeToTokenMap()

in DataExtraction/SourceGraphExtractionUtils/Utils/RoslynUtils.cs [166:255]
89 lines of code
21 McCabe index (conditional complexity)

        public static Dictionary<SyntaxNode, SyntaxToken> CreateNodeToTokenMap(SemanticModel semanticModel,
            Dictionary<SyntaxToken, ISymbol> variableTokens,
            IEnumerable<SyntaxNode> nodes)
        {
            var nodesToTokens = new Dictionary<SyntaxNode, SyntaxToken>();
            foreach (var syntaxNode in nodes)
            {
                SyntaxToken token;
                switch (syntaxNode)
                {
                    case PropertyDeclarationSyntax propDecl:
                        token = propDecl.Identifier;
                        break;
                    case VariableDeclaratorSyntax varDecl:
                        token = varDecl.Identifier;
                        break;
                    case ParameterSyntax parSyn:
                        token = parSyn.Identifier;
                        break;
                    case MethodDeclarationSyntax methodDecl:
                        continue;
                    case AssignmentExpressionSyntax assignExpr:
                        SyntaxNode baseExpr = assignExpr.Left;
                        bool visit = true;
                        while (visit)
                        {
                            visit = false;
                            if (baseExpr is ElementAccessExpressionSyntax access)
                            {
                                baseExpr = access.Expression;
                                visit = true;
                            }
                            else if (baseExpr is PrefixUnaryExpressionSyntax prefSyn)
                            {
                                baseExpr = prefSyn.Operand;
                                visit = true;
                            }
                            else if (baseExpr is CastExpressionSyntax castExpr)
                            {
                                baseExpr = castExpr.Expression;
                                visit = true;
                            }
                        }
                        var symbol = semanticModel.GetSymbolInfo(baseExpr).Symbol;
                        var tokens = baseExpr.DescendantTokens()
                            .Where(t => variableTokens.ContainsKey(t) && (symbol == null || t.Text.Equals(symbol.Name))).ToArray();
                        if (tokens.Length == 1) token = tokens[0];
                        else continue;
                        break;
                    case AccessorDeclarationSyntax accessorSyn:
                        var parent = accessorSyn.Parent.Parent;
                        switch (parent)
                        {
                            case PropertyDeclarationSyntax parentProperty:
                                token = parentProperty.Identifier;
                                break;
                            case IndexerDeclarationSyntax indexerProperty:
                                token = indexerProperty.ThisKeyword;
                                break;
                            case EventDeclarationSyntax eventParent:
                                token = eventParent.Identifier;
                                break;
                            default:
                                throw new Exception("Should not happen: " + parent.GetType());
                        }
                        break;
                    case ForEachStatementSyntax foreachSyn:
                        token = foreachSyn.Identifier;
                        break;
                    default:
                        var nodeTokens = syntaxNode.DescendantTokens().Where(t => variableTokens.ContainsKey(t)).ToList();
                        if (nodeTokens.Count == 1)
                        {
                            token = nodeTokens[0];
                        }
                        else if (nodeTokens.Count == 0)
                        {
                            continue;
                        }
                        else
                        {
                            throw new Exception("This shouldn't happen");
                        }
                        break;
                }
                nodesToTokens.Add(syntaxNode, token);
            }

            return nodesToTokens;
        }