protected override async Task <GotoDefinitionResponse> TranslateResponse(GotoDefinitionResponse response, GotoDefinitionRequest request)
        {
            if (string.IsNullOrEmpty(response.FileName) ||
                !response.FileName.Equals(Constants.Paths.Generated))
            {
                if (PlatformHelper.IsWindows && !string.IsNullOrEmpty(response.FileName))
                {
                    response.FileName = response.FileName.Replace('/', '\\');
                }
                return(response);
            }

            if (!request.WantMetadata)
            {
                return(new GotoDefinitionResponse());
            }

            var alias = (await GotoDefinitionHandlerHelper.GetAliasFromMetadataAsync(
                             Workspace,
                             request.FileName,
                             response.Line,
                             request.Timeout,
                             _metadataExternalSourceService
                             )).FirstOrDefault();

            if (alias == null)
            {
                return(new GotoDefinitionResponse());
            }

            return(new GotoDefinitionResponse
            {
                FileName = alias.MetadataDocument.FilePath ?? alias.MetadataDocument.Name,
                Line = alias.LineSpan.StartLinePosition.Line,
                Column = alias.LineSpan.StartLinePosition.Character,
                MetadataSource = new MetadataSource
                {
                    AssemblyName = alias.Symbol.ContainingAssembly.Name,
                    ProjectName = alias.Document.Project.Name,
                    TypeName = alias.Symbol.GetSymbolName()
                }
            });
        }
        protected override async Task <GotoDefinitionResponse> TranslateResponse(GotoDefinitionResponse response, GotoDefinitionRequest request)
        {
            var definitions = new List <Definition>();

            foreach (var definition in response.Definitions ?? Enumerable.Empty <Definition>())
            {
                var file = definition.Location.FileName;

                if (string.IsNullOrEmpty(file) || !file.Equals(Constants.Paths.Generated))
                {
                    if (PlatformHelper.IsWindows && !string.IsNullOrEmpty(file))
                    {
                        file = file.Replace('/', '\\');
                    }

                    definitions.Add(new Definition
                    {
                        MetadataSource          = definition.MetadataSource,
                        SourceGeneratedFileInfo = definition.SourceGeneratedFileInfo,
                        Location = new Location
                        {
                            FileName = file,
                            Range    = definition.Location.Range
                        }
                    });

                    continue;
                }

                if (!request.WantMetadata)
                {
                    continue;
                }

                var aliasLocations = await GotoDefinitionHandlerHelper.GetAliasFromMetadataAsync(
                    Workspace,
                    request.FileName,
                    definition.Location.Range.End.Line,
                    request.Timeout,
                    _metadataExternalSourceService
                    );

                definitions.AddRange(
                    aliasLocations.Select(loc =>
                                          new Definition
                {
                    Location = new Location
                    {
                        FileName = loc.MetadataDocument.FilePath ?? loc.MetadataDocument.Name,
                        Range    = new Range
                        {
                            Start = new Point
                            {
                                Column = loc.LineSpan.StartLinePosition.Character,
                                Line   = loc.LineSpan.StartLinePosition.Line
                            },
                            End = new Point
                            {
                                Column = loc.LineSpan.EndLinePosition.Character,
                                Line   = loc.LineSpan.EndLinePosition.Line
                            },
                        }
                    },
                    MetadataSource = new MetadataSource
                    {
                        AssemblyName = loc.Symbol.ContainingAssembly.Name,
                        ProjectName  = loc.Document.Project.Name,
                        TypeName     = loc.Symbol.GetSymbolName()
                    },
                    SourceGeneratedFileInfo = new SourceGeneratedFileInfo
                    {
                        DocumentGuid = loc.Document.Id.Id,
                        ProjectGuid  = loc.Document.Id.ProjectId.Id
                    }
                })
                    .ToList());
            }

            return(new GotoDefinitionResponse
            {
                Definitions = definitions
            });
        }