Unable to ignore the method returning Expression with type extension

Is there an existing issue for this?

• I have searched the existing issues

Product

Hot Chocolate

Describe the bug

Suppose a class has a method whose return type is Expression. Also, there's the type extension which adds the ignore directive for that method.

CUR:
The ignore directive isn't actually applied.

Steps to reproduce

Run the reproducible example and in Banana Cake Pop make the retrospective query:

using System;
using System.Linq.Expressions;
using HotChocolate.Types;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace Ademchenko.GraphQLWorkshop.TypeExtensions
{
    public class Query
    {
        public Book Book { get; } = new() { AutorId = 11 };
    }

    public class Book
    {
        public int AutorId { get; set; }

        public Expression<Func<int>> GetExpression() => throw new NotImplementedException();
    }
    
    public class BookTypeExtensions : ObjectTypeExtension<Book>
    {
        protected override void Configure(IObjectTypeDescriptor<Book> descriptor) => descriptor.Ignore(b => b.GetExpression());
    }
    
    /*
    public class BookType : ObjectType<Book>
    {
        protected override void Configure(IObjectTypeDescriptor<Book> descriptor) => descriptor.Ignore(b => b.GetExpression());
    }*/

    public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IConfiguration configuration) => Configuration = configuration;

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();

            services.AddGraphQLServer()
                .AddQueryType<Query>()
                //.AddType<BookType>()
                .AddTypeExtension<BookTypeExtensions>()
                ;
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.UseExceptionHandler(options =>
            {
                options.Run(async context =>
                {
                    var contextFeature = context.Features.Get<IExceptionHandlerFeature>();

                    if (contextFeature != null)
                    {
                        Console.WriteLine(contextFeature.Error);
                    }
                });
            });

            app.UseRouting().UseEndpoints(endpoints => endpoints.MapGraphQL());
        }
    }
}

Relevant log output

1. Unable to infer or resolve a schema type from the type reference `Expression (Input)`.

   at HotChocolate.Configuration.TypeInitializer.DiscoverTypes()
   at HotChocolate.Configuration.TypeInitializer.Initialize()
   at HotChocolate.SchemaBuilder.Setup.InitializeTypes(SchemaBuilder builder, IDescriptorContext context, IReadOnlyList`1 types)
   at HotChocolate.SchemaBuilder.Setup.Create(SchemaBuilder builder, LazySchema lazySchema, IDescriptorContext context)
   at HotChocolate.Execution.RequestExecutorResolver.CreateSchemaAsync(ConfigurationContext context, RequestExecutorSetup setup, RequestExecutorOptions executorOptions, IServiceProvider schemaServices, TypeModuleChangeMonitor typeModuleChangeMonitor, CancellationToken cancellationToken)
   at HotChocolate.Execution.RequestExecutorResolver.CreateSchemaServicesAsync(ConfigurationContext context, RequestExecutorSetup setup, CancellationToken cancellationToken)
   at HotChocolate.Execution.RequestExecutorResolver.GetRequestExecutorNoLockAsync(String schemaName, CancellationToken cancellationToken)
   at HotChocolate.Execution.RequestExecutorResolver.GetRequestExecutorAsync(String schemaName, CancellationToken cancellationToken)
   at HotChocolate.Execution.RequestExecutorProxy.GetRequestExecutorAsync(CancellationToken cancellationToken)
   at HotChocolate.AspNetCore.HttpPostMiddlewareBase.HandleRequestAsync(HttpContext context)
   at HotChocolate.AspNetCore.HttpPostMiddlewareBase.InvokeAsync(HttpContext context)
   at Microsoft.AspNetCore.Builder.EndpointRouteBuilderExtensions.<>c__DisplayClass19_0.<<UseCancellation>b__1>d.MoveNext()
--- End of stack trace from previous location ---
   at Microsoft.AspNetCore.Routing.EndpointMiddleware.<Invoke>g__AwaitRequestTask|6_0(Endpoint endpoint, Task requestTask, ILogger logger)
   at Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware.<Invoke>g__Awaited|6_0(ExceptionHandlerMiddleware middleware, HttpContext context, Task task)

Additional Context?

The ignore functionality works for Type though. To verify that uncomment the code related to BookType.

Version

13.8.1

Start with the reproducible C# example, especially BookTypeExtensions and the descriptor.Ignore call, then follow schema initialization through TypeInitializer.DiscoverTypes() in the reported stack trace. Done means the Expression-returning method is ignored when configured through an ObjectTypeExtension, so schema creation succeeds without the reported type-resolution error.