Interesting Java compiler riddle

generics-type.java

public class Example {
    interface Identifier {}
    class Request {}
    class Response<T extends Identifier> {}
    class ErrorResponse extends Response {}
    
    // the inline lambda and the method _should_ behave exactly the same,
    // but compiler somehow retains parameterzied upper bound type for _lambda_, but not for method.
    
    // Ljava/util/function/Function<LExample$Request;LExample$Response<+LExample$Identifier;>;>;
    private Function<Request, Response<? extends Identifier>> handleWithLambda = response-> new Response<>();          
    // <(LExample$Request;)LExample$Response<+LExample$Identifier;>;>
    private Response<? extends Identifier> nonLambda(Request request) {
        return new Response<>();
    }

    // signature - <()Ljava/util/concurrent/CompletionStage<LExample$Response<+LExample$Identifier;>;>;>
    // Compiles - CompletionStage<Response<extends Identifier>> 
    public CompletionStage<Response <? extends Identifier>> withLambda() {
        return CompletableFuture.completedStage(new Request())
                .thenApply(handleWithLambda)
                .exceptionally(err -> new ErrorResponse());
    }
    
    // Doesn't compile - CompletionStage<Response<capture of extends Identifier>>
    public CompletionStage<Response <? extends Identifier>> withMethod() {
        return CompletableFuture.completedStage(new Request())
                .thenApply(this::nonLambda)
                .exceptionally(err -> new ErrorResponse());
    }
}