diff options
Diffstat (limited to 'java/java-tests/testData/codeInsight/daemonCodeAnalyzer')
26 files changed, 528 insertions, 4 deletions
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/CaptureWildcardFromUnboundCaptureWildcard.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/CaptureWildcardFromUnboundCaptureWildcard.java new file mode 100644 index 000000000000..0abec87dc335 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/CaptureWildcardFromUnboundCaptureWildcard.java @@ -0,0 +1,9 @@ +class Test<X extends Getter<?, ?> & Runnable> {} + +interface Supplier<K> { + K get(); +} + +interface Getter<C, S extends C> extends Supplier<C> { + public S get(); +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA106985.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA106985.java new file mode 100644 index 000000000000..b11bfa46632c --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA106985.java @@ -0,0 +1,15 @@ + +import java.util.Map; + +class Test { + + public static void main(String[] args) { + Map<Integer, Object> map = <error descr="Inferred type 'java.lang.Object' for type parameter 'V' is not within its bound; should implement 'java.lang.Comparable'">make()</error>; + } + + + public static <K extends Comparable, V extends Comparable> Map<K,V> make() { + return null; + } + +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA114797.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA114797.java new file mode 100644 index 000000000000..9e4ee06ade1e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IDEA114797.java @@ -0,0 +1,15 @@ +import java.util.ArrayList; +import java.util.List; + +interface A{}; +interface B extends A{}; + +class GenericTest { + public static <M extends V, V> List<V> convert(List<M> list){ + return new ArrayList<V>(); + } + + public static void test(){ + List<A> as = convert(new ArrayList<B>()); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/constraints/IntersectionTypeStrictSubtypingConstraint.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/constraints/IntersectionTypeStrictSubtypingConstraint.java new file mode 100644 index 000000000000..df18646a0009 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/constraints/IntersectionTypeStrictSubtypingConstraint.java @@ -0,0 +1,15 @@ +import java.io.Serializable; +import java.util.function.Supplier; + +class Test { + static class Loader<K> { + + static <K> Loader<K> from(Supplier<K> supplier) { + return new Loader<>(); + } + } + + Loader loader = Loader.from((I<String> & Serializable) () -> ""); + + interface I<H> extends Supplier<H>{} +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/FreshVariablesCreatedDuringResolveDependingOnAlreadyResolvedVariables.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/FreshVariablesCreatedDuringResolveDependingOnAlreadyResolvedVariables.java new file mode 100644 index 000000000000..a3701f1b6cf8 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/FreshVariablesCreatedDuringResolveDependingOnAlreadyResolvedVariables.java @@ -0,0 +1,17 @@ +class Test { + + class X<F extends Foo, B extends Bar<F, B>> { + } + class Foo { + } + class Bar<A, B> { + } + + private <F extends Foo, B extends Bar<F, B>> X<F, B> foo() { + return null; + } + + { + X x = foo(); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IncompatibleBoundsFromAssignment.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IncompatibleBoundsFromAssignment.java new file mode 100644 index 000000000000..d5b8b03050d5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IncompatibleBoundsFromAssignment.java @@ -0,0 +1,15 @@ +import java.util.Map; + +class Test { + + public static void main(String[] args) { + <error descr="Incompatible types. Found: 'T', required: 'java.util.Map<java.lang.Object,java.lang.Object>'">Map<Object, Object> b = newMapTrie();</error> + <error descr="Incompatible types. Found: 'T', required: 'java.util.Map<java.lang.Object,java.util.Map<java.lang.Object,java.lang.Object>>'">Map<Object, Map<Object, Object>> c = newMapTrie();</error> + <error descr="Incompatible types. Found: 'T', required: 'java.util.Map<java.lang.Object,java.util.Map<java.lang.Object,java.util.Map<java.lang.Object,java.lang.Object>>>'">Map<Object, Map<Object, Map<Object, Object>>> d = newMapTrie();</error> + <error descr="Incompatible types. Found: 'T', required: 'java.util.Map<java.lang.Object,java.util.Map<java.lang.Object,java.util.Map<java.lang.Object,java.util.Map<java.lang.Object,java.lang.Object>>>>'">Map<Object, Map<Object, Map<Object, Map<Object, Object>>>> e = newMapTrie();</error> + } + + public static <T extends Map<Byte, T>> T newMapTrie() { + return null; + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/Ambiguity1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/Ambiguity1.java index e66630146e6f..02bbebd074b0 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/Ambiguity1.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/Ambiguity1.java @@ -12,7 +12,7 @@ class Ambiguity1 { static <T> void m(I2<T> i2) {} { - m<error descr="Ambiguous method call: both 'Ambiguity1.m(I1)' and 'Ambiguity1.m(I2<Object>)' match">(()->{throw new AssertionError();})</error>; + m(()->{throw new AssertionError();}); m(() -> {}); m(() -> { if (false) return; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityRawGenerics.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityRawGenerics.java index 595787704437..6c664dd9e65a 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityRawGenerics.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityRawGenerics.java @@ -22,6 +22,6 @@ class AmbiguityRawGenerics { <Z> void foo(I3<Z> s) { } void bar() { - foo<error descr="Ambiguous method call: both 'AmbiguityRawGenerics.foo(I)' and 'AmbiguityRawGenerics.foo(I1)' match">(()-> { throw new RuntimeException(); })</error>; + foo<error descr="Ambiguous method call: both 'AmbiguityRawGenerics.foo(I1)' and 'AmbiguityRawGenerics.foo(I2)' match">(()-> { throw new RuntimeException(); })</error>; } }
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/EffectiveFinal.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/EffectiveFinal.java index 92b268394994..001b1f39c494 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/EffectiveFinal.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/EffectiveFinal.java @@ -142,3 +142,37 @@ class IDEA128196 { new Thread(() -> System.out.println(value)); } } + +class FinalAssignmentInInitializer { + private final String x; + { + Runnable r = () -> <error descr="Cannot assign a value to final variable 'x'">x</error> = ""; + x = ""; + } +} + +class AssignmentToFinalInsideLambda { + boolean isTrue() { + return true; + } + + Runnable r = () -> { + final int i; + if (isTrue()) { + i = 1; + } else { + i = 0; + } + }; + + void a() { + Runnable r = () -> { + final int i; + if (isTrue()) { + i = 1; + } else { + i = 0; + } + }; + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/NoReturnTypeResolutionForThrownException.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/NoReturnTypeResolutionForThrownException.java index 81429131d099..1fe14f680abe 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/NoReturnTypeResolutionForThrownException.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/NoReturnTypeResolutionForThrownException.java @@ -7,7 +7,7 @@ class Test { void call(I2 p) { } void test() { - call<error descr="Ambiguous method call: both 'Test.call(I1)' and 'Test.call(I2)' match">(() -> { throw new RuntimeException(); })</error>; + call(() -> { throw new RuntimeException(); }); call(() -> { if (true) return ""; throw new RuntimeException(); }); call(() -> { if (true) return; throw new RuntimeException(); }); } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/DeepNestedLambdaExpressionsNoFormalParams.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/DeepNestedLambdaExpressionsNoFormalParams.java new file mode 100644 index 000000000000..5a79aef6a18f --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/DeepNestedLambdaExpressionsNoFormalParams.java @@ -0,0 +1,70 @@ + +import java.util.List; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + + +abstract class Simplified { + public List<Integer> gerFirstTriangles() { + return flatMap(() -> flatMap(() -> map(z -> 1))).collect(Collectors.toList()); + } + + abstract <R> R flatMap(Supplier<R> mapper); + abstract <R> Stream<R> map(Function<Integer, R> mapper); +} + +class PythagoreanTriangles { + + static class Triplet<T,U,R>{ + private T t; + private U u; + private R r; + + public Triplet(T t, U u, R r){ + this.t = t; + this.u = u; + this.r = r; + } + + @Override + public String toString() { + return t.toString() + "," + u.toString() + "," + r.toString(); + } + } + + public void pythagoreanTriangles(Integer num){ + Stream<Integer> numbers = IntStream.rangeClosed(1,num).boxed(); + + Stream<Triplet<Integer, Integer, Integer>> triangles = numbers.flatMap(x -> { + return IntStream.rangeClosed(1, x).boxed().flatMap(y -> { + return IntStream.rangeClosed(1, y).boxed().filter(z -> { + return x * x == y * y + z * z; + }).map(z1 -> new Triplet<Integer, Integer, Integer>(x, y, z1)); + }); + }); + + triangles.forEach(System.out::println); + + } + + public List<Triplet<Integer, Integer, Integer>> gerFirstTriangles(long num){ + Stream<Integer> infinity = Stream.iterate(1, (n) -> n + 1); + return infinity.flatMap(x -> { + return IntStream.rangeClosed(1, x).boxed().flatMap(y -> { + return IntStream.rangeClosed(1, y).boxed().filter(z -> { + return x * x == y * y + z * z; + }).map(z1 -> new Triplet<Integer, Integer, Integer>(x, y, z1)); + }); + }).limit(num).collect(Collectors.toList()); + } + + + public static void main(String[] args) { + PythagoreanTriangles triangles = new PythagoreanTriangles(); + triangles.pythagoreanTriangles(10); + triangles.gerFirstTriangles(5l).forEach(System.out::println); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/IDEA126778.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/IDEA126778.java new file mode 100644 index 000000000000..d8bdcc0d6c82 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/IDEA126778.java @@ -0,0 +1,27 @@ +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static java.util.stream.Collectors.groupingBy; +import static java.util.stream.Collectors.mapping; + +class Test { + private static Map<Long, Long> multiDataPointsToPerTxnSummedValue(final Stream<Map.Entry<DateTime, Map<Long, Long>>> stream) { + return stream.flatMap(e -> e.getValue().entrySet().stream().map(ex -> + new Object() { + Long txId = ex.getKey(); + DataPoint dataPoint = new DataPoint(e.getKey(), ex.getValue()); + } + )).collect(groupingBy(t -> t.txId, mapping(t -> t.dataPoint, Collectors.summingLong(dataPoint -> dataPoint.getValue().longValue())))); + } + + static class MultiDataPoint {} + static class DateTime {} + + static class DataPoint { + DataPoint(DateTime t, Long val) {} + public Long getValue() { + return null; + } + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressions1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressions1.java new file mode 100644 index 000000000000..c31497d1f65a --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressions1.java @@ -0,0 +1,27 @@ +class ExplicitLambdaNoParams { + interface I<T> { + T a(); + } + + <F> I<F> foo(I<F> iff) { return null;} + + { + foo(() -> foo(() -> 1)).a(); + I<Integer> a1 = foo(() -> foo(() -> 1)).a(); + } +} + +class LambdaWithFormalParameterTypes { + + interface I<T> { + T a(int p); + } + + <F> I<F> foo(I<F> iff) { return null;} + + { + foo((int a) -> foo((int b) -> 1)).a(0); + I<Integer> a1 = foo((int a) -> foo((int b) -> 1)).a(0); + } + +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParams.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParams.java new file mode 100644 index 000000000000..2d6254525d44 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParams.java @@ -0,0 +1,55 @@ +import java.util.function.Function; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +abstract class NoFormalParams { + interface I<T> { + T a(int a); + } + + <F> I<F> foo(I<F> i) { return null;} + + { + I<Integer> i = foo(a -> foo(b -> 1)).a(0); + foo(a -> foo(b -> 1)).a(0); + } +} + +abstract class NoFormalParamTypeInferenceNeeded { + interface I<T> { + T a(int a); + } + + abstract <RR> RR map(I<RR> mapper); + abstract <R, V> R zip(Function<V, R> zipper); + + { + map(a -> zip(text -> text)); + zip(a -> zip(text -> text)); + Integer zip = zip(<error descr="Cyclic inference">a -> zip(text -> text)</error>); + } + +} + +class IDEA124983 { + class Rectangle{ + public Rectangle(int i, int j, int h, int w) { + } + } + + void createGrid() { + IntStream.range(0, 4) + .mapToObj(i -> IntStream.range(0, 4).mapToObj(j -> { + Rectangle rect2 = new Rectangle(i * 64, j * 64, 64, 64); + return rect2; + })) + .flatMap(s -> s) + .forEach(this::add); + } + + void add(final Rectangle r) {} + + void simplified(final IntStream range) { + range.mapToObj(i -> range.mapToObj(j -> 1)).flatMap(s -> s); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParams1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParams1.java new file mode 100644 index 000000000000..a3ce57be1db8 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParams1.java @@ -0,0 +1,26 @@ +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +class IDEA129251 { + void simplified(final Stream<String> pStream, final Stream<String> pStream1, final Stream<String> pStream2){ + pStream.flatMap(x -> Stream.concat(pStream1, pStream2.map(String::toUpperCase))); + } + + + private final Set<String> m_allSubtablesColumns; + private final List<SubtableDescription> m_subtablesDescription = null; + + { + m_allSubtablesColumns = m_subtablesDescription.stream(). + flatMap(desc -> Stream.concat(desc.getKeyColumns().stream().map(String::toUpperCase), + desc.getValueColumns().stream().map(String::toUpperCase))). + collect(Collectors.toSet()); + } + + abstract class SubtableDescription { + abstract List<String> getKeyColumns(); + abstract List<String> getValueColumns(); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParamsStopAtStandalone.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParamsStopAtStandalone.java new file mode 100644 index 000000000000..be7be3539813 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/NestedLambdaExpressionsNoFormalParamsStopAtStandalone.java @@ -0,0 +1,32 @@ +import java.util.Map; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collector; +import java.util.stream.Stream; + +class MultiDataPoint { + public MultiDataPoint(final Map<String, String> pCollect) {} + + public static void convertValueResults(final Stream<Result> pStream) { + map(() -> new MultiDataPoint(collect(toMap(r -> r.event.substring(0))))); + } + + static <R> R collect(Collector<? super Result, ?, R> collector) {return null;} + + static <R> R map(Supplier<R> s) { + return null; + } + + static <T, K> Collector<T, ?, Map<K,K>> toMap(Function< T, K> keyMapper) { + return null; + } + + static class Result { + public String event; + + public String getValue() { + return null; + } + } +} + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/ParenthesizedExpressionsDuringConstrainsCollection.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/ParenthesizedExpressionsDuringConstrainsCollection.java new file mode 100644 index 000000000000..2dd69c3dcc79 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/ParenthesizedExpressionsDuringConstrainsCollection.java @@ -0,0 +1,13 @@ +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +abstract class Test { + public List<Integer> gerFirstTriangles() { + return flatMap((y -> (map((z1 -> (1)))))).collect(Collectors.toList()); + } + + abstract <R> R flatMap(Function<Integer, R> mapper); + abstract <R> Stream<R> map (Function<Integer, R> mapper); +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/IDEA127275_.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/IDEA127275_.java index c002468c1b91..5743d171ad28 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/IDEA127275_.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/IDEA127275_.java @@ -4,7 +4,7 @@ import java.util.function.Function; class Main { { - List<Optional<Function<String, String>>> list = asList(of(Main::identity)); + List<Optional<Function<String, String>>> list = asList(of(<error descr="T is not a functional interface">Main::identity</error>)); } static <T> List<T> asList(T a) { return null;} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/IDEA102800.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/IDEA102800.java new file mode 100644 index 000000000000..7c2cc7bdae5e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/IDEA102800.java @@ -0,0 +1,31 @@ +import java.util.function.IntFunction; +import java.util.function.IntUnaryOperator; +import java.util.function.Supplier; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +class Test { + + interface IntStream1 { + Stream<Integer> map(IntFunction<Integer> mapper); + IntStream1 map(IntUnaryOperator mapper); + + Stream<Integer> boxed(); + } + + void fooBar(IntStream1 instr){ + Supplier<Stream<Integer>> si = () -> instr.map ((i) -> (( <error descr="Operator '%' cannot be applied to '<lambda parameter>', 'int'">i % 2</error>) == 0) ? i : <error descr="Incompatible types. Found: '<lambda parameter>', required: '<lambda parameter>'">-i</error>).boxed(); + System.out.println(si); + Supplier<Stream<Integer>> si1 = () -> instr.map <error descr="Ambiguous method call: both 'IntStream1.map(IntFunction<Integer>)' and 'IntStream1.map(IntUnaryOperator)' match">(null)</error>.boxed(); + System.out.println(si1); + } +} + +class TestInitial { + void fooBar(){ + Supplier<Stream<Integer>> si = () -> IntStream.range(0, 20).map((i) -> ((i % 2) == 0) ? i : -i).boxed(); + System.out.println(si); + } +} + + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/PertinentToApplicabilityOfExplicitlyTypedLambda.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/PertinentToApplicabilityOfExplicitlyTypedLambda.java new file mode 100644 index 000000000000..348108fc3443 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/PertinentToApplicabilityOfExplicitlyTypedLambda.java @@ -0,0 +1,17 @@ +abstract class PertinentToApplicabilityOfExplicitlyTypedLambdaTest { + + interface A { + B m(int a); + } + + interface B { + int m(int b); + } + + abstract void foo(A a); + abstract void foo(B b); + + { + foo<error descr="Ambiguous method call: both 'PertinentToApplicabilityOfExplicitlyTypedLambdaTest.foo(A)' and 'PertinentToApplicabilityOfExplicitlyTypedLambdaTest.foo(B)' match">(x -> y -> 42)</error>; + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/VoidValueCompatibilityOfImplicitlyTypedLambda.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/VoidValueCompatibilityOfImplicitlyTypedLambda.java new file mode 100644 index 000000000000..1188a9584dca --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/VoidValueCompatibilityOfImplicitlyTypedLambda.java @@ -0,0 +1,23 @@ +interface A { + int m(int x); +} + +interface B { + void m(boolean x); +} + +abstract class Test { + abstract void foo(A j); + abstract void foo(B i); + + void bar(Object o) { + foo(x -> { + return x += 1; + }); + foo(x -> <error descr="Incompatible types. Found: 'int', required: '<lambda parameter>'">x += 1</error>); + foo(x -> 1); + foo(x -> <error descr="Operator '!' cannot be applied to 'int'">!x</error>); + foo(x -> <error descr="Operator '++' cannot be applied to '<lambda parameter>'">++x</error>); + foo(x -> o instanceof String ? 1 : 0); + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/afterDisjunctionType.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/afterDisjunctionType.java new file mode 100644 index 000000000000..7835cfb40ae9 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/afterDisjunctionType.java @@ -0,0 +1,15 @@ +// "Add 'Exception' as 1st parameter to method 'f'" "true" +import java.io.FileInputStream; +import java.io.IOException; + +class Test { + public void createFileInputStream() { + try { + new FileInputStream("test"); + } catch (IOException |NullPointerException e) { + f(e); + } + } + + public void f(Exception e) { } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforeDisjunctionType.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforeDisjunctionType.java new file mode 100644 index 000000000000..ab28d7484f4d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforeDisjunctionType.java @@ -0,0 +1,15 @@ +// "Add 'Exception' as 1st parameter to method 'f'" "true" +import java.io.FileInputStream; +import java.io.IOException; + +class Test { + public void createFileInputStream() { + try { + new FileInputStream("test"); + } catch (IOException |NullPointerException e) { + f(<caret>e); + } + } + + public void f() { } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/afterVoidValueChangedNoConflict.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/afterVoidValueChangedNoConflict.java new file mode 100644 index 000000000000..295537651974 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/afterVoidValueChangedNoConflict.java @@ -0,0 +1,16 @@ +// "Replace with expression lambda" "true" +class Test { + { + a(() -> new Object(){}); + } + + void a(Supplier<Object> s) {} + void a(AI<Object> s) {} + + interface AI<K> { + void m(); + } + interface Supplier<T> { + T get(); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/beforeVoidValueChanged.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/beforeVoidValueChanged.java new file mode 100644 index 000000000000..20a6c0beac73 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/beforeVoidValueChanged.java @@ -0,0 +1,19 @@ +// "Replace with expression lambda" "false" +interface A { + int m(int x); +} + +interface B { + void m(boolean x); +} + +abstract class X { + abstract void foo(A j); + abstract void foo(B i); + + void bar(Object o) { + foo(x -> { + retu<caret>rn x += 1; + }); + } +}
\ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/beforeVoidValueChangedNoConflict.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/beforeVoidValueChangedNoConflict.java new file mode 100644 index 000000000000..fbbf7ff5f527 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/lambdaCodeBlock2Expr/beforeVoidValueChangedNoConflict.java @@ -0,0 +1,18 @@ +// "Replace with expression lambda" "true" +class Test { + { + a(() -> { + ret<caret>urn new Object(){}; + }); + } + + void a(Supplier<Object> s) {} + void a(AI<Object> s) {} + + interface AI<K> { + void m(); + } + interface Supplier<T> { + T get(); + } +}
\ No newline at end of file |