diff --git a/jdk8-tests/pom.xml b/jdk8-tests/pom.xml
new file mode 100644
index 0000000..a5877fe
--- /dev/null
+++ b/jdk8-tests/pom.xml
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+Copyright (c) 2014 Google, Inc. All rights reserved.
+
+This program is licensed to you under the Apache License Version 2.0,
+and you may not use this file except in compliance with the Apache License Version 2.0.
+You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the Apache License Version 2.0 is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <parent>
+    <artifactId>guice-parent</artifactId>
+    <groupId>com.google.inject</groupId>
+    <version>4.0-SNAPSHOT</version>
+  </parent>
+  <modelVersion>4.0.0</modelVersion>
+
+  <artifactId>jdk8-tests</artifactId>
+
+  <name>Google Guice - JDK8 Tests</name>
+
+  <dependencies>
+    <dependency>
+      <groupId>com.google.inject</groupId>
+      <artifactId>guice</artifactId>
+      <version>${parent.version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>cglib</groupId>
+      <artifactId>cglib</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.guava</groupId>
+      <artifactId>guava-testlib</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <source>8</source>
+          <target>8</target>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+</project>
diff --git a/jdk8-tests/test/com/google/inject/jdk8/DefaultMethodInterceptionTest.java b/jdk8-tests/test/com/google/inject/jdk8/DefaultMethodInterceptionTest.java
new file mode 100644
index 0000000..29e0681
--- /dev/null
+++ b/jdk8-tests/test/com/google/inject/jdk8/DefaultMethodInterceptionTest.java
@@ -0,0 +1,223 @@
+/**
+ * Copyright (C) 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.inject.jdk8;
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.matcher.Matchers;
+
+import junit.framework.TestCase;
+
+import org.aopalliance.intercept.MethodInterceptor;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Tests for interception of default methods.
+ *
+ * @author cgdecker@google.com (Colin Decker)
+ */
+public class DefaultMethodInterceptionTest extends TestCase {
+
+  private static final AtomicInteger callCount = new AtomicInteger(0);
+  private static final AtomicInteger interceptedCallCount = new AtomicInteger(0);
+
+  // the interceptor's a lambda too
+  private final MethodInterceptor interceptor = invocation -> {
+    interceptedCallCount.incrementAndGet();
+    return invocation.proceed();
+  };
+
+  @Override
+  protected void setUp() throws Exception {
+    callCount.set(0);
+    interceptedCallCount.set(0);
+  }
+
+  @Retention(RUNTIME)
+  @Target({METHOD, TYPE})
+  public @interface InterceptMe {}
+
+  /** Interface with a default method annotated to be intercepted. */
+  public interface Foo {
+    @InterceptMe
+    default String defaultMethod() {
+      callCount.incrementAndGet();
+      return "Foo";
+    }
+  }
+
+  /** Foo implementation that does not override the default method. */
+  public static class NonOverridingFoo implements Foo {
+    public String methodCallingDefault() {
+      return "NonOverriding-" + defaultMethod();
+    }
+  }
+
+  public void testInterceptedDefaultMethod() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bindInterceptor(Matchers.any(), Matchers.annotatedWith(InterceptMe.class),
+            interceptor);
+        bind(Foo.class).to(NonOverridingFoo.class);
+      }
+    });
+
+    Foo foo = injector.getInstance(Foo.class);
+    assertEquals("Foo", foo.defaultMethod());
+    assertEquals(1, callCount.get());
+    assertEquals(1, interceptedCallCount.get());
+  }
+
+  public void testInterceptedDefaultMethod_calledByAnotherMethod() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bindInterceptor(Matchers.any(), Matchers.annotatedWith(InterceptMe.class),
+            interceptor);
+      }
+    });
+
+    NonOverridingFoo foo = injector.getInstance(NonOverridingFoo.class);
+    assertEquals("NonOverriding-Foo", foo.methodCallingDefault());
+    assertEquals(1, callCount.get());
+    assertEquals(1, interceptedCallCount.get());
+  }
+
+  /** A base class defining a method with the same signature as Foo's default method. */
+  public static class BaseClass {
+    // the definition of this method on the class will win over the default method
+    public String defaultMethod() {
+      callCount.incrementAndGet();
+      return "BaseClass";
+    }
+  }
+
+  /** Foo implementation that should use superclass method rather than default method. */
+  public static class InheritingFoo extends BaseClass implements Foo {
+  }
+
+  public void testInterceptedDefaultMethod_whenParentClassDefinesNonInterceptedMethod() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bindInterceptor(Matchers.any(), Matchers.annotatedWith(InterceptMe.class),
+            interceptor);
+        bind(Foo.class).to(InheritingFoo.class);
+      }
+    });
+
+    // the concrete implementation that wins is not annotated
+    Foo foo = injector.getInstance(Foo.class);
+    assertEquals("BaseClass", foo.defaultMethod());
+    assertEquals(1, callCount.get());
+    assertEquals(0, interceptedCallCount.get());
+  }
+
+  /**
+   * A base class defining an intercepted method with the same signature as Foo's default method.
+   */
+  public static class BaseClass2 {
+    // the definition of this method on the class will win over the default method
+    @InterceptMe
+    public String defaultMethod() {
+      callCount.incrementAndGet();
+      return "BaseClass2";
+    }
+  }
+
+  /**
+   * Foo implementation that should use intercepted superclass method rather than default method.
+   */
+  public static class InheritingFoo2 extends BaseClass2 implements Foo {
+  }
+
+  public void testInterceptedDefaultMethod_whenParentClassDefinesInterceptedMethod() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bindInterceptor(Matchers.any(), Matchers.annotatedWith(InterceptMe.class),
+            interceptor);
+        bind(Foo.class).to(InheritingFoo2.class);
+      }
+    });
+
+    // the concrete implementation that wins is not annotated
+    Foo foo = injector.getInstance(Foo.class);
+    assertEquals("BaseClass2", foo.defaultMethod());
+    assertEquals(1, callCount.get());
+    assertEquals(1, interceptedCallCount.get());
+  }
+
+  public interface Baz {
+    default String doSomething() {
+      return "Baz";
+    }
+
+    String doSomethingElse();
+  }
+
+  public static class BazImpl implements Baz {
+
+    @Override
+    public String doSomethingElse() {
+      return "BazImpl";
+    }
+  }
+
+  public void testInterception_ofAllMethodsOnType() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bindInterceptor(Matchers.subclassesOf(Baz.class), Matchers.any(), interceptor);
+        bind(Baz.class).to(BazImpl.class);
+      }
+    });
+
+    Baz baz = injector.getInstance(Baz.class);
+
+    assertEquals("Baz", baz.doSomething());
+    assertEquals("BazImpl", baz.doSomethingElse());
+
+    assertEquals(2, interceptedCallCount.get());
+  }
+
+  public void testInterception_ofAllMethodsOnType_interceptsInheritedDefaultMethod() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bindInterceptor(Matchers.subclassesOf(BazImpl.class), Matchers.any(), interceptor);
+        bind(Baz.class).to(BazImpl.class);
+      }
+    });
+
+    Baz baz = injector.getInstance(Baz.class);
+
+    assertEquals("Baz", baz.doSomething());
+    assertEquals("BazImpl", baz.doSomethingElse());
+
+    assertEquals(2, interceptedCallCount.get());
+  }
+}
diff --git a/jdk8-tests/test/com/google/inject/jdk8/Java8LanguageFeatureBindingTest.java b/jdk8-tests/test/com/google/inject/jdk8/Java8LanguageFeatureBindingTest.java
new file mode 100644
index 0000000..9c57cd3
--- /dev/null
+++ b/jdk8-tests/test/com/google/inject/jdk8/Java8LanguageFeatureBindingTest.java
@@ -0,0 +1,165 @@
+/**
+ * Copyright (C) 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.inject.jdk8;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.CreationException;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.google.inject.Provider;
+import com.google.inject.Provides;
+import com.google.inject.ProvisionException;
+import com.google.inject.TypeLiteral;
+
+import junit.framework.TestCase;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Predicate;
+
+/**
+ * Test bindings to lambdas, method references, etc.
+ *
+ * @author cgdecker@google.com (Colin Decker)
+ */
+public class Java8LanguageFeatureBindingTest extends TestCase {
+  
+  // Some of these tests are kind of weird.
+  // See https://github.com/google/guice/issues/757 for more on why they exist.
+
+  public void testBinding_lambdaToInterface() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bind(new TypeLiteral<Predicate<Object>>() {}).toInstance(o -> o != null);
+      }
+    });
+
+    Predicate<Object> predicate = injector.getInstance(new Key<Predicate<Object>>() {});
+    assertTrue(predicate.test(new Object()));
+    assertFalse(predicate.test(null));
+  }
+
+  public void testProviderMethod_returningLambda() throws Exception {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {}
+
+      @Provides
+      public Callable<String> provideCallable() {
+        return () -> "foo";
+      }
+    });
+
+    Callable<String> callable = injector.getInstance(new Key<Callable<String>>() {});
+    assertEquals("foo", callable.call());
+  }
+
+  public void testProviderMethod_containingLambda_throwingException() throws Exception {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {}
+
+      @Provides
+      public Callable<String> provideCallable() {
+        if (Boolean.parseBoolean("false")) { // avoid dead code warnings
+          return () -> "foo";
+        } else {
+          throw new RuntimeException("foo");
+        }
+      }
+    });
+
+    try {
+      injector.getInstance(new Key<Callable<String>>() {});
+    } catch (ProvisionException expected) {
+      assertTrue(expected.getCause() instanceof RuntimeException);
+      assertEquals("foo", expected.getCause().getMessage());
+    }
+  }
+
+  public void testProvider_usingJdk8Features() {
+    try {
+      Guice.createInjector(new AbstractModule() {
+        @Override
+        protected void configure() {
+          bind(String.class).toProvider(StringProvider.class);
+        }
+      });
+
+      fail();
+    } catch (CreationException expected) {
+    }
+
+    UUID uuid = UUID.randomUUID();
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bind(UUID.class).toInstance(uuid);
+        bind(String.class).toProvider(StringProvider.class);
+      }
+    });
+
+    assertEquals(uuid.toString(), injector.getInstance(String.class));
+  }
+
+  private static final class StringProvider implements Provider<String> {
+    private final UUID uuid;
+
+    @Inject
+    StringProvider(UUID uuid) {
+      this.uuid = uuid;
+    }
+
+    @Override
+    public String get() {
+      return Collections.singleton(uuid).stream()
+          .map(UUID::toString)
+          .findFirst().get();
+    }
+  }
+
+  public void testBinding_toProvider_lambda() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        AtomicInteger i = new AtomicInteger();
+        bind(String.class).toProvider(() -> "Hello" + i.incrementAndGet());
+      }
+    });
+
+    assertEquals("Hello1", injector.getInstance(String.class));
+    assertEquals("Hello2", injector.getInstance(String.class));
+  }
+
+  public void testBinding_toProvider_methodReference() {
+    Injector injector = Guice.createInjector(new AbstractModule() {
+      @Override
+      protected void configure() {
+        bind(String.class).toProvider(Java8LanguageFeatureBindingTest.this::provideString);
+      }
+    });
+
+    Provider<String> provider = injector.getProvider(String.class);
+    assertEquals("Hello", provider.get());
+  }
+
+  private String provideString() {
+    return "Hello";
+  }
+}
diff --git a/pom.xml b/pom.xml
index cc93bc7..7ded5d8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -99,6 +99,7 @@
   <modules>
     <module>core</module>
     <module>extensions</module>
+    <!-- jdk8-tests module activated only when running under JDK8, below -->
   </modules>
 
   <prerequisites>
@@ -431,12 +432,17 @@
 
   <profiles>
     <profile>
-      <id>doclint-java8-disable</id>
+      <id>java8</id>
       <activation>
         <jdk>[1.8,)</jdk>
       </activation>
+      <modules>
+        <!-- Activate jdk8-tests module only under JDK 8 -->
+        <module>jdk8-tests</module>
+      </modules>
       <build>
         <plugins>
+          <!-- Disable doclint under JDK 8 -->
           <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-javadoc-plugin</artifactId>