diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/GwtAstBuilder.java b/dev/core/src/com/google/gwt/dev/jjs/impl/GwtAstBuilder.java
index 656fc3a..240860b 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/GwtAstBuilder.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/GwtAstBuilder.java
@@ -1214,14 +1214,7 @@
       // And its JInterface container we must implement
       // There may be more than more JInterface containers to be implemented
       // if the lambda expression is cast to a IntersectionCastType.
-      JInterfaceType[] lambdaInterfaces;
-      if (binding instanceof IntersectionTypeBinding18) {
-        IntersectionTypeBinding18 type = (IntersectionTypeBinding18) binding;
-        lambdaInterfaces =
-            processIntersectionType(type, new JInterfaceType[type.intersectingTypes.length]);
-      } else {
-        lambdaInterfaces = new JInterfaceType[] {(JInterfaceType) typeMap.get(binding)};
-      }
+      JInterfaceType[] lambdaInterfaces = getInterfacesToImplement(binding);
       SourceInfo info = makeSourceInfo(x);
 
       // Create an inner class to implement the interface and SAM method.
@@ -1270,6 +1263,14 @@
       newTypes.add(innerLambdaClass);
     }
 
+    private JInterfaceType[] getInterfacesToImplement(TypeBinding binding) {
+      if (binding instanceof IntersectionTypeBinding18) {
+        IntersectionTypeBinding18 type = (IntersectionTypeBinding18) binding;
+        return processIntersectionType(type, new JInterfaceType[type.intersectingTypes.length]);
+      }
+      return new JInterfaceType[]{(JInterfaceType) typeMap.get(binding)};
+    }
+
     private void createFunctionalExpressionBridges(
         JClassType functionalExpressionImplementationClass,
         FunctionalExpression functionalExpression,
@@ -1771,7 +1772,8 @@
           binding.getSingleAbstractMethod(blockScope, false).original();
       // Get the interface method is binds to
       JMethod interfaceMethod = typeMap.get(declarationSamBinding);
-      JInterfaceType funcType = (JInterfaceType) typeMap.get(binding);
+
+      JInterfaceType[] funcType = getInterfacesToImplement(binding);
       SourceInfo info = makeSourceInfo(x);
 
       // Get the method that the Type::method is actually referring to
diff --git a/dev/core/test/com/google/gwt/dev/jjs/impl/Java8AstTest.java b/dev/core/test/com/google/gwt/dev/jjs/impl/Java8AstTest.java
index a85cb10..ac51d85 100644
--- a/dev/core/test/com/google/gwt/dev/jjs/impl/Java8AstTest.java
+++ b/dev/core/test/com/google/gwt/dev/jjs/impl/Java8AstTest.java
@@ -1117,7 +1117,7 @@
         formatSource(samMethod.toSource()));
   }
 
-  public void testIntersectionCastMultipleAbstractMethods() throws Exception {
+  public void testIntersectionCastOfLambdaMultipleAbstractMethods() throws Exception {
     addSnippetClassDecl("interface I1 { public void foo(); }");
     addSnippetClassDecl("interface I2 { public void foo(); }");
     String lambda = "Object o = (I1 & I2) () -> {};";
@@ -1140,6 +1140,166 @@
         formatSource(samMethod.toSource()));
   }
 
+  public void testIntersectionCastOfLambdaMultipleAbstractMethodsWithGenerics() throws Exception {
+    addSnippetClassDecl("interface I1 extends I2<String> { public void foo(String arg0); }");
+    addSnippetClassDecl("interface I2<T> { public void foo(T arg); }");
+    String lambda = "Object o = (I1 & I2<String>) str -> {};";
+    assertEqualBlock("Object o=(EntryPoint$I1)new EntryPoint$lambda$0$Type();", lambda);
+
+    JProgram program = compileSnippet("void", lambda, false);
+
+    assertNotNull(getMethod(program, "lambda$0"));
+
+    JClassType lambdaInnerClass = (JClassType) getType(program, "test.EntryPoint$lambda$0$Type");
+    assertNotNull(lambdaInnerClass);
+    assertEquals("java.lang.Object", lambdaInnerClass.getSuperClass().getName());
+    assertEquals(1, lambdaInnerClass.getImplements().size());
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I1")));
+    // should implement foo method
+    JMethod samMethod = findMethod(lambdaInnerClass, "foo(Ljava/lang/String;)V");
+    assertEquals("public final void foo(String arg0){EntryPoint.lambda$0(arg0);}",
+        formatSource(samMethod.toSource()));
+  }
+  public void testIntersectionCastOfMethodReference() throws Exception {
+    addSnippetClassDecl("static class C { public static void go() {} }");
+    addSnippetClassDecl("interface I1 { public void foo(); }");
+    addSnippetClassDecl("interface I2 { }");
+    String methodReference = "Object o = (I2 & I1) C::go;";
+    assertEqualBlock("Object o=(EntryPoint$I1)(EntryPoint$I2)new EntryPoint$0methodref$go$Type();",
+        methodReference);
+    JProgram program = compileSnippet("void", methodReference, false);
+
+    // created by GwtAstBuilder
+    JClassType lambdaInnerClass = (JClassType) getType(program, "test.EntryPoint$0methodref$go$Type");
+    assertNotNull(lambdaInnerClass);
+
+    // no fields
+    assertEquals(0, lambdaInnerClass.getFields().size());
+
+    // should have constructor taking no args
+    JMethod ctor = findMethod(lambdaInnerClass, "EntryPoint$0methodref$go$Type");
+    assertTrue(ctor instanceof JConstructor);
+    assertEquals(0, ctor.getParams().size());
+
+    // should implements I1 and I2
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I1")));
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I2")));
+    // should implement foo method
+    JMethod samMethod = findMethod(lambdaInnerClass, "foo");
+    assertEquals("public final void foo(){EntryPoint$C.go();}",
+        formatSource(samMethod.toSource()));
+  }
+
+  public void testMultipleIntersectionCastOfMethodReference() throws Exception {
+    addSnippetClassDecl("static class C { public static void go() {} }");
+    addSnippetClassDecl("interface I1 { public void foo(); }");
+    addSnippetClassDecl("interface I2 { }");
+    addSnippetClassDecl("interface I3 { }");
+    String methodReference = "I2 o = (I3 & I2 & I1) C::go;";
+    assertEqualBlock(
+        "EntryPoint$I2 o=(EntryPoint$I1)(EntryPoint$I2)(EntryPoint$I3)new EntryPoint$0methodref$go$Type();",
+        methodReference);
+
+    JProgram program = compileSnippet("void", methodReference, false);
+
+    // created by GwtAstBuilder
+    JClassType lambdaInnerClass = (JClassType) getType(program, "test.EntryPoint$0methodref$go$Type");
+    assertNotNull(lambdaInnerClass);
+
+    // no fields
+    assertEquals(0, lambdaInnerClass.getFields().size());
+
+    // should have constructor taking no args
+    JMethod ctor = findMethod(lambdaInnerClass, "EntryPoint$0methodref$go$Type");
+    assertTrue(ctor instanceof JConstructor);
+    assertEquals(0, ctor.getParams().size());
+
+    // should extends java.lang.Object, implements I1, I2 and I3
+    assertEquals("java.lang.Object", lambdaInnerClass.getSuperClass().getName());
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I1")));
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I2")));
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I3")));
+    // should implement foo method
+    JMethod samMethod = findMethod(lambdaInnerClass, "foo");
+    assertEquals("public final void foo(){EntryPoint$C.go();}",
+        formatSource(samMethod.toSource()));
+  }
+
+  public void testIntersectionCastOfMethodReferenceOneAbstractMethod() throws Exception {
+    addSnippetClassDecl("static class C { public static void go() {} }");
+    addSnippetClassDecl("interface I1 { public void foo(); }");
+    addSnippetClassDecl("interface I2 extends I1{ public void foo();}");
+    String lambda = "Object o = (I1 & I2) C::go;";
+    // (I1 & I2) is resolved to I2 by JDT.
+    assertEqualBlock("Object o=(EntryPoint$I2)new EntryPoint$0methodref$go$Type();",
+        lambda);
+
+    JProgram program = compileSnippet("void", lambda, false);
+
+    JClassType lambdaInnerClass = (JClassType) getType(program, "test.EntryPoint$0methodref$go$Type");
+    assertNotNull(lambdaInnerClass);
+    assertEquals("java.lang.Object", lambdaInnerClass.getSuperClass().getName());
+    assertEquals(1, lambdaInnerClass.getImplements().size()); // only implements I2.
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I2")));
+    // should implement foo method
+    JMethod samMethod = findMethod(lambdaInnerClass, "foo");
+    assertEquals("public final void foo(){EntryPoint$C.go();}",
+        formatSource(samMethod.toSource()));
+  }
+
+  public void testIntersectionCastOfMethodReferenceMultipleAbstractMethods() throws Exception {
+    addSnippetClassDecl("static class C { public static void go() {} }");
+    addSnippetClassDecl("interface I1 { public void foo(); }");
+    addSnippetClassDecl("interface I2 { public void foo(); }");
+    String methodReference = "Object o = (I1 & I2) C::go;";
+    assertEqualBlock("Object o=(EntryPoint$I1)(EntryPoint$I2)new EntryPoint$0methodref$go$Type();",
+        methodReference);
+
+    JProgram program = compileSnippet("void", methodReference, false);
+
+    JClassType lambdaInnerClass = (JClassType) getType(program, "test.EntryPoint$0methodref$go$Type");
+    assertNotNull(lambdaInnerClass);
+    assertEquals("java.lang.Object", lambdaInnerClass.getSuperClass().getName());
+    assertEquals(2, lambdaInnerClass.getImplements().size());
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I1")));
+  assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I2")));
+    // should implement foo method
+    JMethod samMethod = findMethod(lambdaInnerClass, "foo");
+    assertEquals("public final void foo(){EntryPoint$C.go();}",
+        formatSource(samMethod.toSource()));
+  }
+
+  public void testIntersectionCastOfMethodReferenceMultipleAbstractMethodsWithGenerics() throws Exception {
+    addSnippetClassDecl("static class C { public static void go(String arg) {} }");
+    addSnippetClassDecl("interface I1 extends I2<String> { public void foo(String arg); }");
+    addSnippetClassDecl("interface I2<T> { public void foo(T arg); }");
+    String methodReference = "Object o = (I1 & I2<String>) C::go;";
+    assertEqualBlock("Object o=(EntryPoint$I1)new EntryPoint$0methodref$go$Type();",
+        methodReference);
+
+    JProgram program = compileSnippet("void", methodReference, false);
+
+    JClassType lambdaInnerClass = (JClassType) getType(program, "test.EntryPoint$0methodref$go$Type");
+    assertNotNull(lambdaInnerClass);
+    assertEquals("java.lang.Object", lambdaInnerClass.getSuperClass().getName());
+    assertEquals(1, lambdaInnerClass.getImplements().size());
+    assertTrue(
+        lambdaInnerClass.getImplements().contains(program.getFromTypeMap("test.EntryPoint$I1")));
+    // should implement foo method
+    JMethod samMethod = findMethod(lambdaInnerClass, "foo(Ljava/lang/String;)V");
+    assertEquals("public final void foo(String arg){EntryPoint$C.go(arg);}",
+        formatSource(samMethod.toSource()));
+  }
+
   private static final MockJavaResource LAMBDA_METAFACTORY =
       JavaResourceBase.createMockJavaResource("java.lang.invoke.LambdaMetafactory",
           "package java.lang.invoke;",
diff --git a/user/test-super/com/google/gwt/dev/jjs/super/com/google/gwt/dev/jjs/test/Java8Test.java b/user/test-super/com/google/gwt/dev/jjs/super/com/google/gwt/dev/jjs/test/Java8Test.java
index 907d9f3..a251c73 100644
--- a/user/test-super/com/google/gwt/dev/jjs/super/com/google/gwt/dev/jjs/test/Java8Test.java
+++ b/user/test-super/com/google/gwt/dev/jjs/super/com/google/gwt/dev/jjs/test/Java8Test.java
@@ -1617,7 +1617,7 @@
     assertEquals(4, outer.createInner2Param().apply(1, 2).sum);
     assertEquals(7, outer.createInner3Param().apply(1, 2, 3).sum);
     assertEquals(7, outer.createInner2ParamArray().apply(1, new Integer[] {2, 3}).sum);
-    
+
     // inner class constructor varargs + autoboxing
     assertEquals(2, outer.createInner1IntParam().apply(1).sum);
     assertEquals(4, outer.createInner2IntParam().apply(1, 2).sum);
@@ -2006,7 +2006,7 @@
   ////////////////////////////////////////////////////////////
   //
   //   Tests for language features introduced in Java 9
-  
+
   class Resource implements AutoCloseable {
     boolean isOpen = true;
 
@@ -2080,4 +2080,37 @@
     Predicate p = o -> true;
     assertTrue(p.test(null));
   }
+
+  interface I2<T> { public T foo(T arg); }
+
+  interface I1 extends I2<String> { public String foo(String arg0); }
+
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  public void testIntersectionCastLambda() {
+
+    Object instance = (I1 & I2<String>) val -> "#" + val;
+
+    assertTrue(instance instanceof I1);
+    assertTrue(instance instanceof I2);
+
+    I1 lambda = (I1) instance;
+    I2 raw = lambda;
+    assertEquals("#1", raw.foo("1")); // tests that the bridge exists and is correct
+    assertEquals("#2", lambda.foo("2"));
+  }
+
+  static class C { public static String append(String str) { return "#" + str; } }
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  public void testIntersectionCastMethodReference() {
+
+    Object instance = (I1 & I2<String>) C::append;
+
+    assertTrue(instance instanceof I1);
+    assertTrue(instance instanceof I2);
+
+    I1 lambda = (I1) instance;
+    I2 raw = lambda;
+    assertEquals("#1", raw.foo("1")); // tests that the bridge exists and is correct
+    assertEquals("#2", lambda.foo("2"));
+  }
 }
diff --git a/user/test/com/google/gwt/dev/jjs/test/Java8Test.java b/user/test/com/google/gwt/dev/jjs/test/Java8Test.java
index 312d70c..5e4c773 100644
--- a/user/test/com/google/gwt/dev/jjs/test/Java8Test.java
+++ b/user/test/com/google/gwt/dev/jjs/test/Java8Test.java
@@ -360,6 +360,14 @@
     assertFalse(isGwtSourceLevel9());
   }
 
+  public void testIntersectionCastLambda() {
+    assertFalse(isGwtSourceLevel9());
+  }
+
+  public void testIntersectionCastMethodReference() {
+    assertFalse(isGwtSourceLevel9());
+  }
+
   private boolean isGwtSourceLevel9() {
     return JUnitShell.getCompilerOptions().getSourceLevel().compareTo(SourceLevel.JAVA9) >= 0;
   }