Bug 576128 - Internal Compiler Error: NullPointerException
Summary: Internal Compiler Error: NullPointerException
Status: NEW
Alias: None
Product: JDT
Classification: Eclipse Project
Component: Core (show other bugs)
Version: 4.21   Edit
Hardware: PC Linux
: P3 normal (vote)
Target Milestone: ---   Edit
Assignee: JDT-Core-Inbox CLA
QA Contact:
URL:
Whiteboard: stalebug
Keywords:
Depends on:
Blocks:
 
Reported: 2021-09-20 23:29 EDT by Jack Beaudet CLA
Modified: 2023-09-11 13:11 EDT (History)
0 users

See Also:

Attachments
Add an attachment (proposed patch, testcase, etc.)

Note You need to log in before you can comment on or make changes to this bug.
Description Jack Beaudet CLA 2021-09-20 23:29:37 EDT 
Just updated to 2021-09 and one of my project throws an error when trying to compile it : 

Description	Resource	Path	Location	Type
Internal compiler error: java.lang.NullPointerException: Cannot invoke "org.eclipse.jdt.internal.compiler.lookup.TypeBinding.getSingleAbstractMethod(org.eclipse.jdt.internal.compiler.lookup.Scope, boolean)" because "targetType" is null at org.eclipse.jdt.internal.compiler.ast.LambdaExpression.internalIsCompatibleWith(LambdaExpression.java:906)	PollerUtilsTest.java	/coveo-cloud-utils/src/test/java/com/coveo/cloud/utils/poller	line 0	Java Problem

Here is the source code of the test class, hopefully you can figure it out with it, I cannot share more than that unfortunately : 

import static com.coveo.cloud.utils.poller.PollerUtils.DEFAULT_DURATION_BETWEEN_EXECUTION;
import static com.coveo.cloud.utils.poller.PollerUtils.DEFAULT_POLLER_TIMEOUT;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.time.Duration;
import java.util.Date;
import java.util.concurrent.atomic.AtomicBoolean;

import org.junit.Test;

import com.coveo.cloud.utils.WrappedThrowable;
import com.coveo.cloud.utils.function.CheckedRunnable8E;
import com.coveo.cloud.utils.function.CheckedSupplier8E;

public class PollerUtilsTest
{
    private final long sleepTimeInMs = 1000;
    private final long timeBetweenExecutionInMs = 100;

    @Test
    public void givenThrowingCondition_whenUsingPollUntilNoExceptionAndTimeoutReached_thenShouldReceivedException()
    {
        long startMillis = System.currentTimeMillis();
        assertThrows(RuntimeException.class,
                     () -> PollerUtils.pollUntilNoException(Duration.ofMillis(sleepTimeInMs),
                                                            Duration.ofMillis(timeBetweenExecutionInMs),
                                                            (CheckedRunnable8E<?, ?, ?, ?, ?, ?, ?, ?>) () -> {
                                                                throw new RuntimeException("Noooooooo");
                                                            }));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenThrowingCondition_whenUsingPollUntilNoExceptionWithNoDurationAndTimeoutReached_thenShouldReceivedException()
    {
        long startMillis = System.currentTimeMillis();
        assertThrows(RuntimeException.class,
                     () -> PollerUtils.pollUntilNoException((CheckedRunnable8E<?, ?, ?, ?, ?, ?, ?, ?>) () -> {
                         throw new RuntimeException("Noooooooo");
                     }, () -> {
                         /* Nothing to do!*/}));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '"
                + DEFAULT_POLLER_TIMEOUT.toMillis() + "' ",
                   millisElapsed >= DEFAULT_POLLER_TIMEOUT.toMillis() - DEFAULT_DURATION_BETWEEN_EXECUTION.toMillis());
    }

    @Test
    public void givenTwoConditions_whenUsingPollUntilNoExceptionAndAllConditionStopsThrowing_thenShouldStopPolling()
    {
        AtomicBoolean sleepDone = new AtomicBoolean(false);
        new Thread(() -> {
            try {
                Thread.sleep(sleepTimeInMs / 2); // wait
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
            sleepDone.set(true);
        }).start();

        long startMillis = System.currentTimeMillis();

        PollerUtils.pollUntilNoException(Duration.ofMillis(sleepTimeInMs),
                                         Duration.ofMillis(timeBetweenExecutionInMs),
                                         (CheckedRunnable8E<?, ?, ?, ?, ?, ?, ?, ?>) () -> {
                                             /* Nothing to do!*/},
                                         () -> {
                                             if (!sleepDone.get()) {
                                                 throw new RuntimeException("Noooooooo");
                                             }
                                         });

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test lasted too long. '" + millisElapsed + "' is greater than '" + sleepTimeInMs + "' ",
                   millisElapsed < sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenThrowingCondition_whenUsingReturningPollUntilNoExceptionAndTimeoutReached_thenShouldReceivedException()
    {
        long startMillis = System.currentTimeMillis();
        assertThrows(RuntimeException.class,
                     () -> PollerUtils.pollUntilNoException(Duration.ofMillis(sleepTimeInMs),
                                                            Duration.ofMillis(timeBetweenExecutionInMs),
                                                            (CheckedSupplier8E<?, ?, ?, ?, ?, ?, ?, ?, ?>) () -> {
                                                                throw new RuntimeException("Noooooooo");
                                                            }));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenThrowingCondition_whenUsingReturningPollUntilNoExceptionWithNoDurationAndTimeoutReached_thenShouldReceivedException()
    {
        long startMillis = System.currentTimeMillis();
        assertThrows(RuntimeException.class,
                     () -> PollerUtils.pollUntilNoException((CheckedSupplier8E<?, ?, ?, ?, ?, ?, ?, ?, ?>) () -> {
                         throw new RuntimeException("Noooooooo");
                     }, () -> {
                         /* Nothing to do!*/}));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '"
                + DEFAULT_POLLER_TIMEOUT.toMillis() + "' ",
                   millisElapsed >= DEFAULT_POLLER_TIMEOUT.toMillis() - DEFAULT_DURATION_BETWEEN_EXECUTION.toMillis());
    }

    @Test
    public void givenTwoConditions_whenUsingReturningPollUntilNoExceptionAndAllConditionStopsThrowing_thenShouldStopPolling()
    {
        AtomicBoolean sleepDone = new AtomicBoolean(false);
        Date anObject = new Date();
        new Thread(() -> {
            try {
                Thread.sleep(sleepTimeInMs / 2); // wait
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
            sleepDone.set(true);
        }).start();

        long startMillis = System.currentTimeMillis();

        Date returnedObject = PollerUtils.pollUntilNoException(Duration.ofMillis(sleepTimeInMs),
                                                               Duration.ofMillis(timeBetweenExecutionInMs),
                                                               (CheckedSupplier8E<Date, ?, ?, ?, ?, ?, ?, ?, ?>) () -> {
                                                                   return anObject;
                                                               },
                                                               () -> {
                                                                   if (!sleepDone.get()) {
                                                                       throw new RuntimeException("Noooooooo");
                                                                   }
                                                               });

        assertThat(returnedObject).isSameInstanceAs(anObject);
        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test lasted too long. '" + millisElapsed + "' is greater than '" + sleepTimeInMs + "' ",
                   millisElapsed < sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenCondition_whenUsingPollUntilExceptionAndTimeoutReached_thenShouldReceiveFalse()
    {
        long startMillis = System.currentTimeMillis();
        try {
            PollerUtils.pollUntilException(Duration.ofMillis(sleepTimeInMs),
                                           Duration.ofMillis(timeBetweenExecutionInMs),
                                           RuntimeException.class,
                                           () -> {
                                               /* Nothing to do!*/ });
            fail();
        } catch (PollerTimeoutRuntimeException e) {
        }

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenCondition_whenUsingPollUntilExceptionAndTimeoutReachedWithNoTimeoutAndDefaultTimeoutReached_thenShouldReceiveFalse()
    {
        long startMillis = System.currentTimeMillis();
        try {
            PollerUtils.pollUntilException(RuntimeException.class, () -> {
                /* Nothing to do!*/ });
            fail();
        } catch (PollerTimeoutRuntimeException e) {
        }

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '"
                + DEFAULT_POLLER_TIMEOUT.toMillis() + "' ",
                   millisElapsed >= DEFAULT_POLLER_TIMEOUT.toMillis() - DEFAULT_DURATION_BETWEEN_EXECUTION.toMillis());
    }

    @Test
    public void givenTwoConditions_whenUsingPollUntilExceptionAndAllConditionStartsThrowing_thenShouldStopPolling()
    {
        AtomicBoolean sleepDone = new AtomicBoolean(false);
        new Thread(() -> {
            try {
                Thread.sleep(sleepTimeInMs / 2); // wait
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
            sleepDone.set(true);
        }).start();

        long startMillis = System.currentTimeMillis();

        assertTrue(PollerUtils.pollUntilException(Duration.ofMillis(sleepTimeInMs),
                                                  Duration.ofMillis(timeBetweenExecutionInMs),
                                                  RuntimeException.class,
                                                  () -> {
                                                      throw new RuntimeException("Noooooooo");
                                                  },
                                                  () -> {
                                                      if (sleepDone.get()) {
                                                          throw new RuntimeException("Noooooooo");
                                                      }
                                                  }));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test lasted too long. '" + millisElapsed + "' is greater than '" + sleepTimeInMs + "' ",
                   millisElapsed < sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenTwoConditions_whenUsingPollUntilExceptionAndTimeoutIsReached_thenShouldReceiveLastException()
    {
        long startMillis = System.currentTimeMillis();

        assertThrows(RuntimeException.class,
                     () -> PollerUtils.pollUntilException(Duration.ofMillis(sleepTimeInMs),
                                                          Duration.ofMillis(timeBetweenExecutionInMs),
                                                          RuntimeException.class,
                                                          () -> {
                                                              /* Nothing to do!*/ },
                                                          () -> {
                                                              throw new RuntimeException("Noooooooo");
                                                          }));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenWrappedThrowable_whenUsingPollUntilExceptionAndWrappedExceptionIsThrown_thenShouldReturnTrue()
    {
        assertTrue(PollerUtils.pollUntilException(Duration.ofMillis(sleepTimeInMs),
                                                  Duration.ofMillis(timeBetweenExecutionInMs),
                                                  TestWrappedThrowable.class,
                                                  () -> {
                                                      throw new TestWrappedThrowable(new IllegalStateException());
                                                  }));
    }

    @Test
    public void givenWrappedThrowable_whenUsingPollUntilExceptionAndInnerExceptionIsThrown_thenShouldReturnTrue()
    {
        assertTrue(PollerUtils.pollUntilException(Duration.ofMillis(sleepTimeInMs),
                                                  Duration.ofMillis(timeBetweenExecutionInMs),
                                                  IllegalStateException.class,
                                                  () -> {
                                                      throw new TestWrappedThrowable(new IllegalStateException());
                                                  }));
    }

    @Test
    public void givenWrappedThrowable_whenUsingPollUntilExceptionAndInnerExceptionIsNotThrown_thenShouldReturnTrue()
    {
        long startMillis = System.currentTimeMillis();

        assertThrows(PollerTimeoutRuntimeException.class,
                     () -> PollerUtils.pollUntilException(Duration.ofMillis(sleepTimeInMs),
                                                          Duration.ofMillis(timeBetweenExecutionInMs),
                                                          IllegalStateException.class,
                                                          () -> {
                                                              throw new TestWrappedThrowable(new IllegalArgumentException());
                                                          }));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenWrappedThrowable_whenUsingPollUntilExceptionAndNoExceptionIsThrown_thenShouldReturnTrue()
    {
        long startMillis = System.currentTimeMillis();

        try {
            PollerUtils.pollUntilException(Duration.ofMillis(sleepTimeInMs),
                                           Duration.ofMillis(timeBetweenExecutionInMs),
                                           IllegalStateException.class,
                                           () -> {
                                           });
            fail();
        } catch (PollerTimeoutRuntimeException e) {
        }

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenConditionNeverReached_whenUsingPollUntilConditionSucceedsAndTimeoutReached_thenShouldReceiveFalse()
    {
        long startMillis = System.currentTimeMillis();

        try {
            PollerUtils.pollUntilConditionSucceeds(Duration.ofMillis(sleepTimeInMs),
                                                   Duration.ofMillis(timeBetweenExecutionInMs),
                                                   () -> false);
            fail();
        } catch (PollerTimeoutRuntimeException e) {
        }

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenConditionNeverReached_whenUsingPollUntilConditionSucceedsWithNoDurationAndTimeoutReached_thenShouldReceiveFalse()
    {
        long startMillis = System.currentTimeMillis();

        try {
            PollerUtils.pollUntilConditionSucceeds(() -> false);
            fail();
        } catch (PollerTimeoutRuntimeException e) {
        }

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '"
                + DEFAULT_POLLER_TIMEOUT.toMillis() + "' ",
                   millisElapsed >= DEFAULT_POLLER_TIMEOUT.toMillis() - DEFAULT_DURATION_BETWEEN_EXECUTION.toMillis());
    }

    @Test
    public void givenTwoConditions_whenUsingPollUntilConditionSucceedsAndAllConditionReached_thenShouldReceiveTrue()
    {
        AtomicBoolean conditionReached = new AtomicBoolean(false);
        new Thread(() -> {
            try {
                Thread.sleep(sleepTimeInMs / 2); // wait
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
            conditionReached.set(true);
        }).start();

        long startMillis = System.currentTimeMillis();

        assertTrue(PollerUtils.pollUntilConditionSucceeds(Duration.ofMillis(sleepTimeInMs),
                                                          Duration.ofMillis(timeBetweenExecutionInMs),
                                                          conditionReached::get,
                                                          () -> true));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test lasted too long. '" + millisElapsed + "' is greater than '" + sleepTimeInMs + "' ",
                   millisElapsed < sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenConditionAlwaysInException_whenUsingPollUntilConditionSucceedsAndTimeoutReached_thenShouldReceivedException()
    {
        long startMillis = System.currentTimeMillis();

        assertThrows(RuntimeException.class,
                     () -> PollerUtils.pollUntilConditionSucceeds(Duration.ofMillis(sleepTimeInMs),
                                                                  Duration.ofMillis(timeBetweenExecutionInMs),
                                                                  () -> true,
                                                                  () -> {
                                                                      throw new RuntimeException("Noooooooo");
                                                                  }));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenConditionNeverReached_whenUsingPollUntilConditionFailsAndTimeoutReached_thenShouldReceiveFalse()
    {
        long startMillis = System.currentTimeMillis();

        try {
            PollerUtils.pollUntilConditionFails(Duration.ofMillis(sleepTimeInMs),
                                                Duration.ofMillis(timeBetweenExecutionInMs),
                                                () -> true);
            fail();
        } catch (PollerTimeoutRuntimeException e) {
        }

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenConditionNeverReached_whenUsingPollUntilConditionFailsWithNoDurationAndTimeoutReached_thenShouldReceiveFalse()
    {
        long startMillis = System.currentTimeMillis();

        try {
            PollerUtils.pollUntilConditionFails(() -> true);
            fail();
        } catch (PollerTimeoutRuntimeException e) {
        }

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '"
                + DEFAULT_POLLER_TIMEOUT.toMillis() + "' ",
                   millisElapsed >= DEFAULT_POLLER_TIMEOUT.toMillis() - DEFAULT_DURATION_BETWEEN_EXECUTION.toMillis());
    }

    @Test
    public void givenTwoConditions_whenUsingPollUntilConditionFailsAndAllConditionReached_thenShouldReceiveTrue()
    {
        AtomicBoolean conditionReached = new AtomicBoolean(true);
        new Thread(() -> {
            try {
                Thread.sleep(sleepTimeInMs / 2); // wait
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
            conditionReached.set(false);
        }).start();

        long startMillis = System.currentTimeMillis();

        assertTrue(PollerUtils.pollUntilConditionFails(Duration.ofMillis(sleepTimeInMs),
                                                       Duration.ofMillis(timeBetweenExecutionInMs),
                                                       conditionReached::get,
                                                       () -> false));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test lasted too long. '" + millisElapsed + "' is greater than '" + sleepTimeInMs + "' ",
                   millisElapsed < sleepTimeInMs - timeBetweenExecutionInMs);
    }

    @Test
    public void givenConditionAlwaysInException_whenUsingPollUntilConditionFailsAndTimeoutReached_thenShouldReceivedException()
    {
        long startMillis = System.currentTimeMillis();

        assertThrows(RuntimeException.class,
                     () -> PollerUtils.pollUntilConditionFails(Duration.ofMillis(sleepTimeInMs),
                                                               Duration.ofMillis(timeBetweenExecutionInMs),
                                                               () -> true,
                                                               () -> {
                                                                   throw new RuntimeException("Noooooooo");
                                                               }));

        long endMillis = System.currentTimeMillis();
        long millisElapsed = endMillis - startMillis;
        assertTrue("Test didn't last long enough. '" + millisElapsed + "' is not greater than '" + sleepTimeInMs + "' ",
                   millisElapsed >= sleepTimeInMs - timeBetweenExecutionInMs);
    }

    private static class TestWrappedThrowable extends Throwable implements WrappedThrowable
    {
        private static final long serialVersionUID = 1L;

        private Throwable innerThrowable;

        public TestWrappedThrowable(Throwable innerThrowable)
        {
            this.innerThrowable = innerThrowable;
        }

        @Override
        public Throwable getInnerThrowable()
        {
            return innerThrowable;
        }
    }
}

Complete stack trace from the logs : 
!ENTRY org.eclipse.jdt.core.manipulation 4 0 2021-09-20 23:28:06.467
!MESSAGE Error in JDT Core during AST creation
!STACK 0
java.lang.NullPointerException: Cannot invoke "org.eclipse.jdt.internal.compiler.lookup.TypeBinding.getSingleAbstractMethod(org.eclipse.jdt.internal.compiler.lookup.Scope, boolean)" because "targetType" is null
	at org.eclipse.jdt.internal.compiler.ast.LambdaExpression.internalIsCompatibleWith(LambdaExpression.java:906)
	at org.eclipse.jdt.internal.compiler.ast.LambdaExpression.isCompatibleWith(LambdaExpression.java:886)
	at org.eclipse.jdt.internal.compiler.lookup.ConstraintExpressionFormula.reduce(ConstraintExpressionFormula.java:75)
	at org.eclipse.jdt.internal.compiler.lookup.BoundSet.reduceOneConstraint(BoundSet.java:985)
	at org.eclipse.jdt.internal.compiler.lookup.InferenceContext18.reduce(InferenceContext18.java:1072)
	at org.eclipse.jdt.internal.compiler.lookup.InferenceContext18.solve(InferenceContext18.java:1023)
	at org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding.computeCompatibleMethod18(ParameterizedGenericMethodBinding.java:249)
	at org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding.computeCompatibleMethod(ParameterizedGenericMethodBinding.java:92)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.computeCompatibleMethod(Scope.java:841)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.computeCompatibleMethod(Scope.java:798)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.findMethod0(Scope.java:1753)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.findMethod(Scope.java:1654)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.getMethod(Scope.java:3039)
	at org.eclipse.jdt.internal.compiler.ast.CastExpression.checkAlternateBinding(CastExpression.java:349)
	at org.eclipse.jdt.internal.compiler.ast.CastExpression.checkNeedForArgumentCasts(CastExpression.java:226)
	at org.eclipse.jdt.internal.compiler.ast.ASTNode.checkInvocationArguments(ASTNode.java:452)
	at org.eclipse.jdt.internal.compiler.ast.MessageSend.resolveType(MessageSend.java:950)
	at org.eclipse.jdt.internal.compiler.ast.ReturnStatement.resolve(ReturnStatement.java:321)
	at org.eclipse.jdt.internal.compiler.ast.LambdaExpression.resolveType(LambdaExpression.java:456)
	at org.eclipse.jdt.internal.compiler.ast.LambdaExpression.cachedResolvedCopy(LambdaExpression.java:992)
	at org.eclipse.jdt.internal.compiler.ast.LambdaExpression.internalIsCompatibleWith(LambdaExpression.java:895)
	at org.eclipse.jdt.internal.compiler.ast.LambdaExpression.isCompatibleWith(LambdaExpression.java:886)
	at org.eclipse.jdt.internal.compiler.lookup.ConstraintExpressionFormula.reduce(ConstraintExpressionFormula.java:75)
	at org.eclipse.jdt.internal.compiler.lookup.BoundSet.reduceOneConstraint(BoundSet.java:985)
	at org.eclipse.jdt.internal.compiler.lookup.InferenceContext18.reduce(InferenceContext18.java:1072)
	at org.eclipse.jdt.internal.compiler.lookup.InferenceContext18.solve(InferenceContext18.java:1023)
	at org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding.computeCompatibleMethod18(ParameterizedGenericMethodBinding.java:249)
	at org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding.computeCompatibleMethod(ParameterizedGenericMethodBinding.java:92)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.computeCompatibleMethod(Scope.java:841)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.computeCompatibleMethod(Scope.java:798)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.findMethod0(Scope.java:1753)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.findMethod(Scope.java:1654)
	at org.eclipse.jdt.internal.compiler.lookup.Scope.getImplicitMethod(Scope.java:2744)
	at org.eclipse.jdt.internal.compiler.ast.MessageSend.findMethodBinding(MessageSend.java:1013)
	at org.eclipse.jdt.internal.compiler.ast.MessageSend.resolveType(MessageSend.java:835)
	at org.eclipse.jdt.internal.compiler.ast.Expression.resolve(Expression.java:1113)
	at org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration.resolveStatements(AbstractMethodDeclaration.java:661)
	at org.eclipse.jdt.internal.compiler.ast.MethodDeclaration.resolveStatements(MethodDeclaration.java:362)
	at org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration.resolve(AbstractMethodDeclaration.java:570)
	at org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve(TypeDeclaration.java:1503)
	at org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve(TypeDeclaration.java:1628)
	at org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration.resolve(CompilationUnitDeclaration.java:667)
	at org.eclipse.jdt.core.dom.CompilationUnitResolver.resolve(CompilationUnitResolver.java:1240)
	at org.eclipse.jdt.core.dom.CompilationUnitResolver.resolve(CompilationUnitResolver.java:712)
	at org.eclipse.jdt.core.dom.ASTParser.internalCreateAST(ASTParser.java:1253)
	at org.eclipse.jdt.core.dom.ASTParser.createAST(ASTParser.java:868)
	at org.eclipse.jdt.core.manipulation.CoreASTProvider$1.run(CoreASTProvider.java:272)
	at org.eclipse.core.runtime.SafeRunner.run(SafeRunner.java:45)
	at org.eclipse.jdt.core.manipulation.CoreASTProvider.createAST(CoreASTProvider.java:264)
	at org.eclipse.jdt.core.manipulation.CoreASTProvider.getAST(CoreASTProvider.java:197)
	at org.eclipse.jdt.core.manipulation.SharedASTProviderCore.getAST(SharedASTProviderCore.java:138)
	at org.eclipse.jdt.internal.ui.viewsupport.SelectionListenerWithASTManager$PartListenerGroup.calculateASTandInform(SelectionListenerWithASTManager.java:166)
	at org.eclipse.jdt.internal.ui.viewsupport.SelectionListenerWithASTManager$PartListenerGroup$1.run(SelectionListenerWithASTManager.java:151)
	at org.eclipse.core.internal.jobs.Worker.run(Worker.java:63)
Comment 1 Eclipse Genie CLA 2023-09-11 13:11:22 EDT 
This bug hasn't had any activity in quite some time. Maybe the problem got resolved, was a duplicate of something else, or became less pressing for some reason - or maybe it's still relevant but just hasn't been looked at yet.

If you have further information on the current state of the bug, please add it. The information can be, for example, that the problem still occurs, that you still want the feature, that more information is needed, or that the bug is (for whatever reason) no longer relevant.

--
The automated Eclipse Genie.