diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test0/in/TestInlineLambda.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test0/in/TestInlineLambda.java
new file mode 100644
index 0000000..d98d9a9
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test0/in/TestInlineLambda.java
@@ -0,0 +1,58 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineLambda {
+	public static final FI fi = x -> x++;
+
+	static { 
+		FI a = fi;	// [1]	
+		FI b;
+		b = fi;		// [2]		
+	}
+	
+	private FI fun1() {
+		return fi;	// [3]
+	}
+	
+	FI[] c = new FI[] {fi, fi}; // [4]
+	FI[][] d = new FI[][] {{fi, fi}, {fi}}; // [5]
+	FI[] e = {fi, fi}; // [6]
+	FI[][] f = {{fi}, {fi}}; // [7]
+	
+	int g = fun2(fi);	// [8]
+	TestInlineLambda h = new TestInlineLambda(fi);	// [9]
+	private int fun2(FI fi) {return 0;}
+	public TestInlineLambda(FI fi) {}
+
+	private void fun3() {
+		F f1 = (fi_p) -> fi;	// [10]
+		F f2 = (fi_p) -> {
+			return fi;		// [11]
+		};
+		boolean flag = true;
+		FI fi4 = flag ? fi : fi; // [12]
+	}
+
+	enum E {
+		E_C1(fi);  // [13]
+		E(FI fi) {
+		}
+	}
+
+}
+
+enum E1 {
+	E_C1(TestInlineLambda.fi); // [14]
+	E1(FI fi) {
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(Object o);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test0/out/TestInlineLambda.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test0/out/TestInlineLambda.java
new file mode 100644
index 0000000..5656775
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test0/out/TestInlineLambda.java
@@ -0,0 +1,56 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineLambda {
+	static { 
+		FI a = x -> x++;	// [1]	
+		FI b;
+		b = x -> x++;		// [2]		
+	}
+	
+	private FI fun1() {
+		return x -> x++;	// [3]
+	}
+	
+	FI[] c = new FI[] {x -> x++, x -> x++}; // [4]
+	FI[][] d = new FI[][] {{x -> x++, x -> x++}, {x -> x++}}; // [5]
+	FI[] e = {x -> x++, x -> x++}; // [6]
+	FI[][] f = {{x -> x++}, {x -> x++}}; // [7]
+	
+	int g = fun2(x -> x++);	// [8]
+	TestInlineLambda h = new TestInlineLambda(x -> x++);	// [9]
+	private int fun2(FI fi) {return 0;}
+	public TestInlineLambda(FI fi) {}
+
+	private void fun3() {
+		F f1 = (fi_p) -> x -> x++;	// [10]
+		F f2 = (fi_p) -> {
+			return x -> x++;		// [11]
+		};
+		boolean flag = true;
+		FI fi4 = flag ? x -> x++ : x -> x++; // [12]
+	}
+
+	enum E {
+		E_C1(x -> x++);  // [13]
+		E(FI fi) {
+		}
+	}
+
+}
+
+enum E1 {
+	E_C1(x -> x++); // [14]
+	E1(FI fi) {
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(Object o);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1/in/TestInlineLambda_Cast.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1/in/TestInlineLambda_Cast.java
new file mode 100644
index 0000000..6d7af08
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1/in/TestInlineLambda_Cast.java
@@ -0,0 +1,47 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineLambda_Cast {
+	public static final FI fi = x -> x++;
+
+	private FI fun3() {
+		F a = o -> null;
+		return a.bar(fi); // [1]
+	}
+
+	private Object fun5() {
+		Object o = fi; // [2]
+		F fx = (z) -> {
+			z = fi; // [3]
+			return null;
+		};
+
+		Object fi2;
+		fi2 = fi; // [4]
+
+		Object[] b = new Object[] { fi, fi }; // [5]
+		Object[][] c = new Object[][] { { fi }, { fi } }; // [6]
+		Object[] d = { fi, fi }; // [7]
+		Object[][] e = { { fi }, { fi } }; // [8]
+
+		System.out.println(fi); // [9]
+
+		Object fi4 = true ? fi : fi; // [10]
+		System.out.println(true ? fi : fi); // [11]
+
+		int x2 = fi.foo(10); // [12]
+
+		return fi; // [13]
+	}
+
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(Object o);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1/out/TestInlineLambda_Cast.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1/out/TestInlineLambda_Cast.java
new file mode 100644
index 0000000..fec18ab
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1/out/TestInlineLambda_Cast.java
@@ -0,0 +1,45 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineLambda_Cast {
+	private FI fun3() {
+		F a = o -> null;
+		return a.bar((FI) x -> x++); // [1]
+	}
+
+	private Object fun5() {
+		Object o = (FI) x -> x++; // [2]
+		F fx = (z) -> {
+			z = (FI) x -> x++; // [3]
+			return null;
+		};
+
+		Object fi2;
+		fi2 = (FI) x -> x++; // [4]
+
+		Object[] b = new Object[] { (FI) x -> x++, (FI) x -> x++ }; // [5]
+		Object[][] c = new Object[][] { { (FI) x -> x++ }, { (FI) x -> x++ } }; // [6]
+		Object[] d = { (FI) x -> x++, (FI) x -> x++ }; // [7]
+		Object[][] e = { { (FI) x -> x++ }, { (FI) x -> x++ } }; // [8]
+
+		System.out.println((FI) x -> x++); // [9]
+
+		Object fi4 = true ? (FI) x -> x++ : (FI) x -> x++; // [10]
+		System.out.println(true ? (FI) x -> x++ : (FI) x -> x++); // [11]
+
+		int x2 = ((FI) x -> x++).foo(10); // [12]
+
+		return (FI) x -> x++; // [13]
+	}
+
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(Object o);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1000/in/TestInlineMethodRef.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1000/in/TestInlineMethodRef.java
new file mode 100644
index 0000000..f75d50f
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1000/in/TestInlineMethodRef.java
@@ -0,0 +1,49 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineMethodRef {
+	public static final FI fi = TestInlineMethodRef::m;
+	
+	private static int m(int x) {
+		return x++;
+	}
+
+	static { 
+		FI a = fi;	// [1]	
+		FI b;
+		b = fi;		// [2]		
+	}
+	
+	private FI fun1() {
+		return fi;	// [3]
+	}
+	
+	FI[] c = new FI[] {fi, fi}; // [4]
+	FI[][] d = new FI[][] {{fi, fi}, {fi}}; // [5]
+	FI[] e = {fi, fi}; // [6]
+	FI[][] f = {{fi}, {fi}}; // [7]
+	
+	int g = fun2(fi);	// [8]
+	TestInlineMethodRef h = new TestInlineMethodRef(fi);	// [9]
+	private int fun2(FI fi) {return 0;}
+	public TestInlineMethodRef(FI fi) {}
+
+	private void fun3() {
+		F f1 = (fi_p) -> fi;	// [10]
+		F f2 = (fi_p) -> {
+			return fi;		// [11]
+		};
+		boolean flag = true;
+		FI fi4 = flag ? fi : fi; // [12]
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(Object o);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1000/out/TestInlineMethodRef.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1000/out/TestInlineMethodRef.java
new file mode 100644
index 0000000..9d9c601
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1000/out/TestInlineMethodRef.java
@@ -0,0 +1,47 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineMethodRef {
+	private static int m(int x) {
+		return x++;
+	}
+
+	static { 
+		FI a = TestInlineMethodRef::m;	// [1]	
+		FI b;
+		b = TestInlineMethodRef::m;		// [2]		
+	}
+	
+	private FI fun1() {
+		return TestInlineMethodRef::m;	// [3]
+	}
+	
+	FI[] c = new FI[] {TestInlineMethodRef::m, TestInlineMethodRef::m}; // [4]
+	FI[][] d = new FI[][] {{TestInlineMethodRef::m, TestInlineMethodRef::m}, {TestInlineMethodRef::m}}; // [5]
+	FI[] e = {TestInlineMethodRef::m, TestInlineMethodRef::m}; // [6]
+	FI[][] f = {{TestInlineMethodRef::m}, {TestInlineMethodRef::m}}; // [7]
+	
+	int g = fun2(TestInlineMethodRef::m);	// [8]
+	TestInlineMethodRef h = new TestInlineMethodRef(TestInlineMethodRef::m);	// [9]
+	private int fun2(FI fi) {return 0;}
+	public TestInlineMethodRef(FI fi) {}
+
+	private void fun3() {
+		F f1 = (fi_p) -> TestInlineMethodRef::m;	// [10]
+		F f2 = (fi_p) -> {
+			return TestInlineMethodRef::m;		// [11]
+		};
+		boolean flag = true;
+		FI fi4 = flag ? TestInlineMethodRef::m : TestInlineMethodRef::m; // [12]
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(Object o);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1001/in/TestInlineMethodRef_Cast.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1001/in/TestInlineMethodRef_Cast.java
new file mode 100644
index 0000000..5ecec4d
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1001/in/TestInlineMethodRef_Cast.java
@@ -0,0 +1,50 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineMethodRef_Cast {
+	public static final FI fi = TestInlineMethodRef_Cast::m;
+	
+	private static int m(int x) {
+		return x++;
+	}
+
+	private FI fun3() {
+		F a = o -> null;
+		return a.bar(fi); // [1]
+	}
+
+	private Object fun5() {
+		Object o = fi; // [2]
+		F fx = (z) -> {
+			z = fi; // [3]
+			return null;
+		};
+
+		Object fi2;
+		fi2 = fi; // [4]
+
+		Object[] b = new Object[] { fi, fi }; // [5]
+		Object[][] c = new Object[][] { { fi }, { fi } }; // [6]
+		Object[] d = { fi, fi }; // [7]
+		Object[][] e = { { fi }, { fi } }; // [8]
+
+		System.out.println(fi); // [9]
+
+		Object fi4 = true ? fi : fi; // [10]
+		System.out.println(true ? fi : fi); // [11]
+
+		int x2 = fi.foo(10); // [12]
+
+		return fi; // [13]
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(Object o);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1001/out/TestInlineMethodRef_Cast.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1001/out/TestInlineMethodRef_Cast.java
new file mode 100644
index 0000000..0c307f6
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1001/out/TestInlineMethodRef_Cast.java
@@ -0,0 +1,48 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineMethodRef_Cast {
+	private static int m(int x) {
+		return x++;
+	}
+
+	private FI fun3() {
+		F a = o -> null;
+		return a.bar((FI) TestInlineMethodRef_Cast::m); // [1]
+	}
+
+	private Object fun5() {
+		Object o = (FI) TestInlineMethodRef_Cast::m; // [2]
+		F fx = (z) -> {
+			z = (FI) TestInlineMethodRef_Cast::m; // [3]
+			return null;
+		};
+
+		Object fi2;
+		fi2 = (FI) TestInlineMethodRef_Cast::m; // [4]
+
+		Object[] b = new Object[] { (FI) TestInlineMethodRef_Cast::m, (FI) TestInlineMethodRef_Cast::m }; // [5]
+		Object[][] c = new Object[][] { { (FI) TestInlineMethodRef_Cast::m }, { (FI) TestInlineMethodRef_Cast::m } }; // [6]
+		Object[] d = { (FI) TestInlineMethodRef_Cast::m, (FI) TestInlineMethodRef_Cast::m }; // [7]
+		Object[][] e = { { (FI) TestInlineMethodRef_Cast::m }, { (FI) TestInlineMethodRef_Cast::m } }; // [8]
+
+		System.out.println((FI) TestInlineMethodRef_Cast::m); // [9]
+
+		Object fi4 = true ? (FI) TestInlineMethodRef_Cast::m : (FI) TestInlineMethodRef_Cast::m; // [10]
+		System.out.println(true ? (FI) TestInlineMethodRef_Cast::m : (FI) TestInlineMethodRef_Cast::m); // [11]
+
+		int x2 = ((FI) TestInlineMethodRef_Cast::m).foo(10); // [12]
+
+		return (FI) TestInlineMethodRef_Cast::m; // [13]
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(Object o);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1002/in/TestInlineMethodRefArray.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1002/in/TestInlineMethodRefArray.java
new file mode 100644
index 0000000..8e9f383
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1002/in/TestInlineMethodRefArray.java
@@ -0,0 +1,20 @@
+// 5, 30 -> 5, 35  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineMethodRefArray {
+	public static final FI[] fiArr = { TestInlineMethodRefArray::m };
+
+	private static int m(int x) {
+		return x++;
+	}
+
+	FI[] a = fiArr;
+	FI[][] b = { fiArr };
+	Object[] c = fiArr;
+	Object[][] d = { fiArr };
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1002/out/TestInlineMethodRefArray.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1002/out/TestInlineMethodRefArray.java
new file mode 100644
index 0000000..fbeae1a
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1002/out/TestInlineMethodRefArray.java
@@ -0,0 +1,18 @@
+// 5, 30 -> 5, 35  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineMethodRefArray {
+	private static int m(int x) {
+		return x++;
+	}
+
+	FI[] a = new FI[]{ TestInlineMethodRefArray::m };
+	FI[][] b = { new FI[]{ TestInlineMethodRefArray::m } };
+	Object[] c = new FI[]{ TestInlineMethodRefArray::m };
+	Object[][] d = { new FI[]{ TestInlineMethodRefArray::m } };
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1003/in/TestInlineMethodRef_Ambiguous.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1003/in/TestInlineMethodRef_Ambiguous.java
new file mode 100644
index 0000000..94aad6d
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1003/in/TestInlineMethodRef_Ambiguous.java
@@ -0,0 +1,51 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestClass extends SuperClass {
+	public static final FI fi = TestClass::m;
+	private static int m(int x) {
+		return x++;
+	}
+	
+	{
+		bar(0, fi); // [1]
+		super.bar(0, fi); // [2]
+	}
+	
+	TestClass() {
+		this(0, fi); // [3]
+	}
+	
+	TestClass(int i, FI a) {
+		super(i, fi); // [4]
+	}
+
+	TestClass(int i, FX b) { }
+
+	{
+		new TestClass(0, fi); // [5]
+	}
+
+	void bar(int x, FX fx) { 
+		System.out.println();
+	}
+}
+
+class SuperClass {
+	public SuperClass() { }
+	SuperClass(int i, FI fi) { }
+	SuperClass(int x, FX fx) { }
+
+	void bar(int i, FI fi) { }
+	void bar(int x, FX fx) { }
+}
+
+@FunctionalInterface
+interface FI {
+int foo(int x);
+}
+
+@FunctionalInterface
+interface FX {
+int foo(String s);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1003/out/TestInlineMethodRef_Ambiguous.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1003/out/TestInlineMethodRef_Ambiguous.java
new file mode 100644
index 0000000..8defc90
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test1003/out/TestInlineMethodRef_Ambiguous.java
@@ -0,0 +1,50 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestClass extends SuperClass {
+	private static int m(int x) {
+		return x++;
+	}
+	
+	{
+		bar(0, (FI) TestClass::m); // [1]
+		super.bar(0, (FI) TestClass::m); // [2]
+	}
+	
+	TestClass() {
+		this(0, (FI) TestClass::m); // [3]
+	}
+	
+	TestClass(int i, FI a) {
+		super(i, (FI) TestClass::m); // [4]
+	}
+
+	TestClass(int i, FX b) { }
+
+	{
+		new TestClass(0, (FI) TestClass::m); // [5]
+	}
+
+	void bar(int x, FX fx) { 
+		System.out.println();
+	}
+}
+
+class SuperClass {
+	public SuperClass() { }
+	SuperClass(int i, FI fi) { }
+	SuperClass(int x, FX fx) { }
+
+	void bar(int i, FI fi) { }
+	void bar(int x, FX fx) { }
+}
+
+@FunctionalInterface
+interface FI {
+int foo(int x);
+}
+
+@FunctionalInterface
+interface FX {
+int foo(String s);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test2/in/TestInlineLambdaArray.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test2/in/TestInlineLambdaArray.java
new file mode 100644
index 0000000..b7ef711
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test2/in/TestInlineLambdaArray.java
@@ -0,0 +1,15 @@
+// 5, 30 -> 5, 35  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineLambdaArray {
+	public static final FI[] fiArr = { x -> x++ };
+	FI[] a = fiArr;
+	FI[][] b = { fiArr };
+	Object[] c = fiArr;
+	Object[][] d = { fiArr };
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test2/out/TestInlineLambdaArray.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test2/out/TestInlineLambdaArray.java
new file mode 100644
index 0000000..3b2d34a
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test2/out/TestInlineLambdaArray.java
@@ -0,0 +1,14 @@
+// 5, 30 -> 5, 35  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestInlineLambdaArray {
+	FI[] a = new FI[]{ x -> x++ };
+	FI[][] b = { new FI[]{ x -> x++ } };
+	Object[] c = new FI[]{ x -> x++ };
+	Object[][] d = { new FI[]{ x -> x++ } };
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test3/in/TestInlineLambda_Ambiguous.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test3/in/TestInlineLambda_Ambiguous.java
new file mode 100644
index 0000000..7fdb425
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test3/in/TestInlineLambda_Ambiguous.java
@@ -0,0 +1,54 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestClass extends SuperClass {
+	public static final FI fi = x -> x++;
+	
+	{
+		bar(0, fi); // [1]
+		super.bar(0, fi); // [2]
+	}
+	
+	TestClass() {
+		this(0, fi); // [3]
+	}
+	
+	TestClass(int i, FI a) {
+		super(i, fi); // [4]
+	}
+
+	TestClass(int i, FX b) { }
+
+	{
+		new TestClass(0, fi); // [5]
+	}
+
+	void bar(int x, FX fx) { 
+		System.out.println();
+	}
+}
+
+class SuperClass {
+	public SuperClass() { }
+	SuperClass(int i, FI fi) { }
+	SuperClass(int x, FX fx) { }
+
+	void bar(int i, FI fi) { }
+	void bar(int x, FX fx) { }
+}
+
+enum E {
+	EE(0, TestClass.fi); // [6]
+	E(int i, FI fi) { }
+	E(int s, FX fl) { }
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface FX {
+	int foo(String s);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test3/out/TestInlineLambda_Ambiguous.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test3/out/TestInlineLambda_Ambiguous.java
new file mode 100644
index 0000000..3bf6e58
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test3/out/TestInlineLambda_Ambiguous.java
@@ -0,0 +1,52 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestClass extends SuperClass {
+	{
+		bar(0, (FI) x -> x++); // [1]
+		super.bar(0, (FI) x -> x++); // [2]
+	}
+	
+	TestClass() {
+		this(0, (FI) x -> x++); // [3]
+	}
+	
+	TestClass(int i, FI a) {
+		super(i, (FI) x -> x++); // [4]
+	}
+
+	TestClass(int i, FX b) { }
+
+	{
+		new TestClass(0, (FI) x -> x++); // [5]
+	}
+
+	void bar(int x, FX fx) { 
+		System.out.println();
+	}
+}
+
+class SuperClass {
+	public SuperClass() { }
+	SuperClass(int i, FI fi) { }
+	SuperClass(int x, FX fx) { }
+
+	void bar(int i, FI fi) { }
+	void bar(int x, FX fx) { }
+}
+
+enum E {
+	EE(0, (FI) x -> x++); // [6]
+	E(int i, FI fi) { }
+	E(int s, FX fl) { }
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface FX {
+	int foo(String s);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test4/in/TestInlineLambda_Ambiguous.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test4/in/TestInlineLambda_Ambiguous.java
new file mode 100644
index 0000000..7a7fd6d
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test4/in/TestInlineLambda_Ambiguous.java
@@ -0,0 +1,36 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestClassN extends SuperClassN implements SuperInterfaceN {
+	public static final FI fi = x -> x++;
+	
+	{
+		bar1(0, fi); // [1]
+		bar2(0, fi); // [2]
+		bar3(0, fi, 1); // [3]
+	}
+	
+	void bar1(int x, FI fi) { }
+	void bar2(int x, FI fi) { }
+	
+	void bar3(int i, FI fi, int j) { }
+	void bar3(int i, String s, int j) { }
+}
+
+class SuperClassN {
+	private void bar1(int i, FX fx) { }
+}
+
+interface SuperInterfaceN {
+	static void bar2(int i, FX fx) { };
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface FX {
+	int foo(String s);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test4/out/TestInlineLambda_Ambiguous.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test4/out/TestInlineLambda_Ambiguous.java
new file mode 100644
index 0000000..4bccbcb
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test4/out/TestInlineLambda_Ambiguous.java
@@ -0,0 +1,34 @@
+// 5, 28 -> 5, 30  replaceAll = true, removeDeclaration = true
+package p;
+
+class TestClassN extends SuperClassN implements SuperInterfaceN {
+	{
+		bar1(0, x -> x++); // [1]
+		bar2(0, x -> x++); // [2]
+		bar3(0, x -> x++, 1); // [3]
+	}
+	
+	void bar1(int x, FI fi) { }
+	void bar2(int x, FI fi) { }
+	
+	void bar3(int i, FI fi, int j) { }
+	void bar3(int i, String s, int j) { }
+}
+
+class SuperClassN {
+	private void bar1(int i, FX fx) { }
+}
+
+interface SuperInterfaceN {
+	static void bar2(int i, FX fx) { };
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface FX {
+	int foo(String s);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test5/in/TestInlineLambda_Cast.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test5/in/TestInlineLambda_Cast.java
new file mode 100644
index 0000000..f02be50
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test5/in/TestInlineLambda_Cast.java
@@ -0,0 +1,22 @@
+// 15, 30 -> 15, 36  replaceAll = true, removeDeclaration = true
+package p;
+
+interface ISup {
+	int foo(double x);
+	int foo(float x);
+}
+
+@FunctionalInterface
+interface FSub {
+	int foo(int x);
+}
+
+class TestInlineLambda1 {
+	public static final FSub fi_sub = x -> x++;
+
+	{
+		fun1((ISup) fi_sub);
+	}
+
+	private void fun1(ISup sup) { }
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test5/out/TestInlineLambda_Cast.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test5/out/TestInlineLambda_Cast.java
new file mode 100644
index 0000000..ee0b4a4
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineConstant/canInline18/test5/out/TestInlineLambda_Cast.java
@@ -0,0 +1,20 @@
+// 15, 30 -> 15, 36  replaceAll = true, removeDeclaration = true
+package p;
+
+interface ISup {
+	int foo(double x);
+	int foo(float x);
+}
+
+@FunctionalInterface
+interface FSub {
+	int foo(int x);
+}
+
+class TestInlineLambda1 {
+	{
+		fun1((ISup) (FSub) x -> x++);
+	}
+
+	private void fun1(ISup sup) { }
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test0_in.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test0_in.java
new file mode 100644
index 0000000..6f909b9
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test0_in.java
@@ -0,0 +1,40 @@
+package p;
+
+class TestInlineLambda0 {
+	
+	private FI fun1() {
+		final FI fi = x -> x++;
+		
+		FI fi1 = fi;	// [1]
+		FI fi2;
+		fi2 = fi;		// [2]	
+		
+		FI[] a = new FI[] {fi, fi}; // [3]
+		FI[][] b = new FI[][] {{fi, fi}, {fi}}; // [4]
+		FI[] c = {fi, fi}; // [5]
+		FI[][] d = {{fi}, {fi}}; // [6]
+	
+		int x1 = fun2(fi);	// [7]
+		TestInlineLambda0 c1 = new TestInlineLambda0(fi);	// [8]
+		F f1 = (fi_p) -> fi;	// [9]
+		F f2 = (fi_p) -> {
+			return fi;		// [10]
+		};
+		f1.bar(fi); // [11]
+		FI fi4 = true ? fi : fi; // [12]
+		return fi;		// [13]
+	}
+	
+	private int fun2(FI fi) {return 0;}
+	public TestInlineLambda0(FI fi) { }
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(FI fi);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test0_out.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test0_out.java
new file mode 100644
index 0000000..b8e7931
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test0_out.java
@@ -0,0 +1,38 @@
+package p;
+
+class TestInlineLambda0 {
+	
+	private FI fun1() {
+		FI fi1 = x -> x++;	// [1]
+		FI fi2;
+		fi2 = x -> x++;		// [2]	
+		
+		FI[] a = new FI[] {x -> x++, x -> x++}; // [3]
+		FI[][] b = new FI[][] {{x -> x++, x -> x++}, {x -> x++}}; // [4]
+		FI[] c = {x -> x++, x -> x++}; // [5]
+		FI[][] d = {{x -> x++}, {x -> x++}}; // [6]
+	
+		int x1 = fun2(x -> x++);	// [7]
+		TestInlineLambda0 c1 = new TestInlineLambda0(x -> x++);	// [8]
+		F f1 = (fi_p) -> x -> x++;	// [9]
+		F f2 = (fi_p) -> {
+			return x -> x++;		// [10]
+		};
+		f1.bar(x -> x++); // [11]
+		FI fi4 = true ? x -> x++ : x -> x++; // [12]
+		return x -> x++;		// [13]
+	}
+	
+	private int fun2(FI fi) {return 0;}
+	public TestInlineLambda0(FI fi) { }
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(FI fi);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1000_in.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1000_in.java
new file mode 100644
index 0000000..eaabf2a
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1000_in.java
@@ -0,0 +1,44 @@
+package p;
+
+class TestInlineMethodReference0 {
+	
+	private FI fun1() {
+		final FI fi = this::m;
+		
+		FI fi1 = fi;	// [1]
+		FI fi2;
+		fi2 = fi;		// [2]	
+		
+		FI[] a = new FI[] {fi, fi}; // [3]
+		FI[][] b = new FI[][] {{fi, fi}, {fi}}; // [4]
+		FI[] c = {fi, fi}; // [5]
+		FI[][] d = {{fi}, {fi}}; // [6]
+	
+		int x1 = fun2(fi);	// [7]
+		TestInlineMethodReference0 c1 = new TestInlineMethodReference0(fi);	// [8]
+		F f1 = (fi_p) -> fi;	// [9]
+		F f2 = (fi_p) -> {
+			return fi;		// [10]
+		};
+		f1.bar(fi); // [11]
+		FI fi4 = true ? fi : fi; // [12]
+		return fi;		// [13]
+	}
+	
+	private int fun2(FI fi) {return 0;}
+	public TestInlineMethodReference0(FI fi) { }
+	
+	int m(int x) {
+		return x++;
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(FI fi);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1000_out.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1000_out.java
new file mode 100644
index 0000000..aee68cd
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1000_out.java
@@ -0,0 +1,42 @@
+package p;
+
+class TestInlineMethodReference0 {
+	
+	private FI fun1() {
+		FI fi1 = this::m;	// [1]
+		FI fi2;
+		fi2 = this::m;		// [2]	
+		
+		FI[] a = new FI[] {this::m, this::m}; // [3]
+		FI[][] b = new FI[][] {{this::m, this::m}, {this::m}}; // [4]
+		FI[] c = {this::m, this::m}; // [5]
+		FI[][] d = {{this::m}, {this::m}}; // [6]
+	
+		int x1 = fun2(this::m);	// [7]
+		TestInlineMethodReference0 c1 = new TestInlineMethodReference0(this::m);	// [8]
+		F f1 = (fi_p) -> this::m;	// [9]
+		F f2 = (fi_p) -> {
+			return this::m;		// [10]
+		};
+		f1.bar(this::m); // [11]
+		FI fi4 = true ? this::m : this::m; // [12]
+		return this::m;		// [13]
+	}
+	
+	private int fun2(FI fi) {return 0;}
+	public TestInlineMethodReference0(FI fi) { }
+	
+	int m(int x) {
+		return x++;
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	FI bar(FI fi);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1001_in.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1001_in.java
new file mode 100644
index 0000000..c97a034
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1001_in.java
@@ -0,0 +1,44 @@
+package p;
+
+class TestInlineMethodReference1 {
+	
+	private Object fun1() {
+		final FI fi = this::m;
+		
+		Object fi1 = fi;	// [1]
+		Object fi2;
+		fi2 = fi;		// [2]	
+		
+		Object[] a = new Object[] {fi, fi}; // [3]
+		Object[][] b = new Object[][] {{fi, fi}, {fi}}; // [4]
+		Object[] c = {fi, fi}; // [5]
+		Object[][] d = {{fi}, {fi}}; // [6]
+	
+		int x1 = fun2(fi);	// [7]
+		TestInlineMethodReference1 c1 = new TestInlineMethodReference1(fi);	// [8]
+		F f1 = (fi_p) -> fi;	// [9]
+		F f2 = (fi_p) -> {
+			return fi;		// [10]
+		};
+		f1.bar(fi); // [11]
+		Object fi4 = true ? fi : fi; // [12]
+		return fi;		// [13]
+	}
+	
+	private int fun2(Object fi) {return 0;}
+	public TestInlineMethodReference1(Object fi) { }
+	
+	int m(int x) {
+		return x++;
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	Object bar(Object fi);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1001_out.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1001_out.java
new file mode 100644
index 0000000..288d3c4
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1001_out.java
@@ -0,0 +1,42 @@
+package p;
+
+class TestInlineMethodReference1 {
+	
+	private Object fun1() {
+		Object fi1 = (FI) this::m;	// [1]
+		Object fi2;
+		fi2 = (FI) this::m;		// [2]	
+		
+		Object[] a = new Object[] {(FI) this::m, (FI) this::m}; // [3]
+		Object[][] b = new Object[][] {{(FI) this::m, (FI) this::m}, {(FI) this::m}}; // [4]
+		Object[] c = {(FI) this::m, (FI) this::m}; // [5]
+		Object[][] d = {{(FI) this::m}, {(FI) this::m}}; // [6]
+	
+		int x1 = fun2((FI) this::m);	// [7]
+		TestInlineMethodReference1 c1 = new TestInlineMethodReference1((FI) this::m);	// [8]
+		F f1 = (fi_p) -> ((FI) this::m);	// [9]
+		F f2 = (fi_p) -> {
+			return (FI) this::m;		// [10]
+		};
+		f1.bar((FI) this::m); // [11]
+		Object fi4 = true ? (FI) this::m : (FI) this::m; // [12]
+		return (FI) this::m;		// [13]
+	}
+	
+	private int fun2(Object fi) {return 0;}
+	public TestInlineMethodReference1(Object fi) { }
+	
+	int m(int x) {
+		return x++;
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	Object bar(Object fi);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1_in.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1_in.java
new file mode 100644
index 0000000..f0af076
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1_in.java
@@ -0,0 +1,40 @@
+package p;
+
+class TestInlineLambda1 {
+	
+	private Object fun1() {
+		final FI fi = x -> x++;
+		
+		Object fi1 = fi;	// [1]
+		Object fi2;
+		fi2 = fi;		// [2]	
+		
+		Object[] a = new Object[] {fi, fi}; // [3]
+		Object[][] b = new Object[][] {{fi, fi}, {fi}}; // [4]
+		Object[] c = {fi, fi}; // [5]
+		Object[][] d = {{fi}, {fi}}; // [6]
+	
+		int x1 = fun2(fi);	// [7]
+		TestInlineLambda1 c1 = new TestInlineLambda1(fi);	// [8]
+		F f1 = (fi_p) -> fi;	// [9]
+		F f2 = (fi_p) -> {
+			return fi;		// [10]
+		};
+		f1.bar(fi); // [11]
+		Object fi4 = true ? fi : fi; // [12]
+		return fi;		// [13]
+	}
+	
+	private int fun2(Object fi) {return 0;}
+	public TestInlineLambda1(Object fi) { }
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	Object bar(Object fi);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1_out.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1_out.java
new file mode 100644
index 0000000..f95c62b
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test1_out.java
@@ -0,0 +1,38 @@
+package p;
+
+class TestInlineLambda1 {
+	
+	private Object fun1() {
+		Object fi1 = (FI) x -> x++;	// [1]
+		Object fi2;
+		fi2 = (FI) x -> x++;		// [2]	
+		
+		Object[] a = new Object[] {(FI) x -> x++, (FI) x -> x++}; // [3]
+		Object[][] b = new Object[][] {{(FI) x -> x++, (FI) x -> x++}, {(FI) x -> x++}}; // [4]
+		Object[] c = {(FI) x -> x++, (FI) x -> x++}; // [5]
+		Object[][] d = {{(FI) x -> x++}, {(FI) x -> x++}}; // [6]
+	
+		int x1 = fun2((FI) x -> x++);	// [7]
+		TestInlineLambda1 c1 = new TestInlineLambda1((FI) x -> x++);	// [8]
+		F f1 = (fi_p) -> ((FI) x -> x++);	// [9]
+		F f2 = (fi_p) -> {
+			return (FI) x -> x++;		// [10]
+		};
+		f1.bar((FI) x -> x++); // [11]
+		Object fi4 = true ? (FI) x -> x++ : (FI) x -> x++; // [12]
+		return (FI) x -> x++;		// [13]
+	}
+	
+	private int fun2(Object fi) {return 0;}
+	public TestInlineLambda1(Object fi) { }
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
+
+@FunctionalInterface
+interface F {
+	Object bar(Object fi);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test2_in.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test2_in.java
new file mode 100644
index 0000000..37af135
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test2_in.java
@@ -0,0 +1,16 @@
+package p;
+
+class TestInlineLambda2 {
+	private void fun1() {
+		final FI[] fiArr = {x -> x++};		
+		FI[] a = fiArr;
+		FI[][] b = {fiArr};
+		Object[] c = fiArr;
+		Object[][] d = {fiArr};
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test2_out.java b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test2_out.java
new file mode 100644
index 0000000..8a0cbac
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/resources/InlineTemp/canInline18/A_test2_out.java
@@ -0,0 +1,15 @@
+package p;
+
+class TestInlineLambda2 {
+	private void fun1() {
+		FI[] a = new FI[]{x -> x++};
+		FI[][] b = {new FI[]{x -> x++}};
+		Object[] c = new FI[]{x -> x++};
+		Object[][] d = {new FI[]{x -> x++}};
+	}
+}
+
+@FunctionalInterface
+interface FI {
+	int foo(int x);
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/AllRefactoringTests.java b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/AllRefactoringTests.java
index ce939fa..0889434 100644
--- a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/AllRefactoringTests.java
+++ b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/AllRefactoringTests.java
@@ -22,6 +22,8 @@
 		TestSuite suite= new TestSuite(clazz.getName());
 
 		suite.addTest(RenameTests18.suite());
+		suite.addTest(InlineTempTests18.suite());
+		suite.addTest(InlineConstantTests18.suite());
 
 		//--code
 		suite.addTest(ExtractMethodTests.suite());
diff --git a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/InlineConstantTests18.java b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/InlineConstantTests18.java
new file mode 100644
index 0000000..c845b6e
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/InlineConstantTests18.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2013 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * This is an implementation of an early-draft specification developed under the Java
+ * Community Process (JCP) and is made available for testing and evaluation purposes
+ * only. The code is not compatible with any specification of the JCP.
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.ui.tests.refactoring;
+
+import junit.framework.Test;
+
+public class InlineConstantTests18 extends InlineConstantTests {
+	private static final Class clazz= InlineConstantTests18.class;
+
+	public InlineConstantTests18(String name) {
+		super(name);
+	}
+
+	@Override
+	protected String successPath() {
+		return toSucceed ? "/canInline18/" : "/cannotInline18/";
+	}
+
+	public static Test suite() {
+		return new Java18Setup(new NoSuperTestsSuite(clazz));
+	}
+
+	public static Test setUpTest(Test someTest) {
+		return new Java18Setup(someTest);
+	}
+
+	//--- Test lambda expressions
+
+	public void test0() throws Exception {
+		helper1("p.TestInlineLambda", 5, 28, 5, 30, true, true);
+	}
+
+	public void test1() throws Exception {
+		helper1("p.TestInlineLambda_Cast", 5, 28, 5, 30, true, true);
+	}
+
+	public void test2() throws Exception {
+		helper1("p.TestInlineLambdaArray", 5, 30, 5, 35, true, true);
+	}
+
+	public void test3() throws Exception {
+		helper1("p.TestInlineLambda_Ambiguous", 5, 28, 5, 30, true, true);
+	}
+
+	public void test4() throws Exception {
+		helper1("p.TestInlineLambda_Ambiguous", 5, 28, 5, 30, true, true);
+	}
+
+	public void test5() throws Exception {
+		helper1("p.TestInlineLambda_Cast", 15, 30, 15, 36, true, true);
+	}
+
+	//--- Test method references
+
+	public void test1000() throws Exception {
+		helper1("p.TestInlineMethodRef", 5, 28, 5, 30, true, true);
+	}
+
+	public void test1001() throws Exception {
+		helper1("p.TestInlineMethodRef_Cast", 5, 28, 5, 30, true, true);
+	}
+
+	public void test1002() throws Exception {
+		helper1("p.TestInlineMethodRefArray", 5, 30, 5, 35, true, true);
+	}
+
+	public void test1003() throws Exception {
+		helper1("p.TestInlineMethodRef_Ambiguous", 5, 28, 5, 30, true, true);
+	}
+}
diff --git a/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/InlineTempTests18.java b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/InlineTempTests18.java
new file mode 100644
index 0000000..768b869
--- /dev/null
+++ b/org.eclipse.jdt.ui.tests.refactoring/test cases/org/eclipse/jdt/ui/tests/refactoring/InlineTempTests18.java
@@ -0,0 +1,66 @@
+/*******************************************************************************
+ * Copyright (c) 2013 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * This is an implementation of an early-draft specification developed under the Java
+ * Community Process (JCP) and is made available for testing and evaluation purposes
+ * only. The code is not compatible with any specification of the JCP.
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.ui.tests.refactoring;
+
+import junit.framework.Test;
+
+public class InlineTempTests18 extends InlineTempTests {
+
+	private static final Class clazz= InlineTempTests18.class;
+
+	public InlineTempTests18(String name) {
+		super(name);
+	}
+
+	public static Test suite() {
+		return new Java18Setup(new NoSuperTestsSuite(clazz));
+	}
+
+	public static Test setUpTest(Test someTest) {
+		return new Java18Setup(someTest);
+	}
+
+	@Override
+	protected String getTestFileName(boolean canInline, boolean input) {
+		String fileName= TEST_PATH_PREFIX + getRefactoringPath();
+		fileName+= (canInline ? "canInline18/" : "cannotInline18/");
+		return fileName + getSimpleTestFileName(canInline, input);
+	}
+
+	//--- tests for lambda expressions
+
+	public void test0() throws Exception {
+		helper1(6, 18, 6, 20);
+	}
+
+	public void test1() throws Exception {
+		helper1(6, 18, 6, 20);
+	}
+
+	public void test2() throws Exception {
+		helper1(5, 20, 5, 25);
+	}
+
+	//--- tests for method references
+
+	public void test1000() throws Exception {
+		helper1(6, 18, 6, 20);
+	}
+
+	public void test1001() throws Exception {
+		helper1(6, 18, 6, 20);
+	}
+
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/dom/ASTNodes.java b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/dom/ASTNodes.java
index 93a35d8..e86e33e 100644
--- a/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/dom/ASTNodes.java
+++ b/org.eclipse.jdt.ui/core extension/org/eclipse/jdt/internal/corext/dom/ASTNodes.java
@@ -75,6 +75,7 @@
 import org.eclipse.jdt.core.dom.Message;
 import org.eclipse.jdt.core.dom.MethodDeclaration;
 import org.eclipse.jdt.core.dom.MethodInvocation;
+import org.eclipse.jdt.core.dom.MethodReference;
 import org.eclipse.jdt.core.dom.Modifier;
 import org.eclipse.jdt.core.dom.Name;
 import org.eclipse.jdt.core.dom.NameQualifiedType;
@@ -600,7 +601,17 @@
 			
 		} else if (initializerType.isRawType() && referenceType.isParameterizedType()) {
 			return referenceType; // don't lose the unchecked conversion
-			
+
+		} else if (initializer instanceof LambdaExpression || initializer instanceof MethodReference) {
+			if (isTargetAmbiguous(reference)) {
+				return referenceType;
+			} else {
+				ITypeBinding targetType= getTargetType(reference);
+				if (targetType == null || targetType != referenceType) {
+					return referenceType;
+				}
+			}
+
 		} else if (! TypeRules.canAssign(initializerType, referenceType)) {
 			if (!Bindings.containsTypeVariables(referenceType))
 				return referenceType;