diff --git a/pkg/analyzer/lib/src/generated/ffi_verifier.dart b/pkg/analyzer/lib/src/generated/ffi_verifier.dart
index 9e6b40d..467f542 100644
--- a/pkg/analyzer/lib/src/generated/ffi_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/ffi_verifier.dart
@@ -488,7 +488,8 @@
       if (_isPointerInterfaceType(nativeType)) {
         final nativeArgumentType = nativeType.typeArguments.single;
         return _isValidFfiNativeType(nativeArgumentType, true) ||
-            _isStructClass(nativeArgumentType);
+            _isStructClass(nativeArgumentType) ||
+            _isNativeTypeInterfaceType(nativeArgumentType);
       }
     } else if (nativeType is FunctionType) {
       return _isValidFfiNativeFunctionType(nativeType);
@@ -539,6 +540,17 @@
     return false;
   }
 
+  // Returns `true` iff [nativeType] is a `ffi.NativeType` type.
+  bool _isNativeTypeInterfaceType(DartType nativeType) {
+    if (nativeType is InterfaceType) {
+      final element = nativeType.element;
+      if (element.library.name == 'dart.ffi') {
+        return element.name == 'NativeType';
+      }
+    }
+    return false;
+  }
+
   // Returns `true` iff [nativeType] is a struct type.
   _isStructClass(DartType nativeType) {
     if (nativeType is InterfaceType) {
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index 8f24710..b99e4e9 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -1496,53 +1496,73 @@
     if (optional(".", token) ||
         optional("..", token) ||
         optional("?..", token)) {
-      return doDotOrCascadeExpression(token);
+      doDotOrCascadeExpression(token);
+    } else if (optional("&&", token) || optional("||", token)) {
+      doLogicalExpression(token);
+    } else if (optional("??", token)) {
+      doIfNull(token);
+    } else if (optional("?.", token)) {
+      doIfNotNull(token);
+    } else {
+      doBinaryExpression(token);
     }
-    if (optional("&&", token) || optional("||", token)) {
-      return doLogicalExpression(token);
-    }
-    if (optional("??", token)) return doIfNull(token);
-    if (optional("?.", token)) return doIfNotNull(token);
-    Expression argument = popForValue();
-    Object receiver = pop();
-    bool isSuper = false;
-    if (receiver is ThisAccessGenerator && receiver.isSuper) {
-      ThisAccessGenerator thisAccessorReceiver = receiver;
-      isSuper = true;
-      receiver = forest.createThisExpression(thisAccessorReceiver.fileOffset);
-    }
-    push(buildBinaryOperator(toValue(receiver), token, argument, isSuper));
   }
 
-  Expression buildBinaryOperator(
-      Expression a, Token token, Expression b, bool isSuper) {
+  void doBinaryExpression(Token token) {
+    assert(checkState(token, <ValueKind>[
+      unionOfKinds([ValueKind.Expression, ValueKind.Generator]),
+      unionOfKinds([ValueKind.Expression, ValueKind.Generator]),
+    ]));
+    Expression right = popForValue();
+    Object left = pop();
     bool negate = false;
     String operator = token.stringValue;
     if (identical("!=", operator)) {
       operator = "==";
       negate = true;
     }
+    int fileOffset = offsetForToken(token);
+    Name name = new Name(operator);
     if (!isBinaryOperator(operator) && !isMinusOperator(operator)) {
       if (isUserDefinableOperator(operator)) {
-        return buildProblem(
-            fasta.templateNotBinaryOperator.withArguments(token),
-            token.charOffset,
-            token.length);
+        push(buildProblem(fasta.templateNotBinaryOperator.withArguments(token),
+            token.charOffset, token.length));
       } else {
-        return buildProblem(fasta.templateInvalidOperator.withArguments(token),
-            token.charOffset, token.length);
+        push(buildProblem(fasta.templateInvalidOperator.withArguments(token),
+            token.charOffset, token.length));
       }
+    } else if (left is ExplicitExtensionAccessGenerator) {
+      // TODO(johnniwinther): Use this code path for all generators. Currently
+      // TypeUseGenerator starts complaining about `Map<` not being a method
+      // instead of `<` not defined on `Type`.
+      Object result = left.buildPropertyAccess(
+          new SendAccessGenerator(this, token, name,
+              forest.createArguments(fileOffset, <Expression>[right]),
+              isPotentiallyConstant: true),
+          fileOffset,
+          false);
+      push(negate ? forest.createNot(fileOffset, toValue(result)) : result);
     } else {
+      bool isSuper = false;
+      Expression leftValue;
+      if (left is ThisAccessGenerator && left.isSuper) {
+        ThisAccessGenerator thisAccessorReceiver = left;
+        isSuper = true;
+        leftValue =
+            forest.createThisExpression(thisAccessorReceiver.fileOffset);
+      } else {
+        leftValue = toValue(left);
+      }
       Expression result = buildMethodInvocation(
-          a,
-          new Name(operator),
-          forest.createArguments(token.charOffset, <Expression>[b]),
+          leftValue,
+          name,
+          forest.createArguments(fileOffset, <Expression>[right]),
           token.charOffset,
           // This *could* be a constant expression, we can't know without
-          // evaluating [a] and [b].
+          // evaluating [left] and [right].
           isConstantExpression: !isSuper,
           isSuper: isSuper);
-      return negate ? forest.createNot(token.charOffset, result) : result;
+      push(negate ? forest.createNot(fileOffset, result) : result);
     }
   }
 
@@ -3341,29 +3361,51 @@
 
   @override
   void handleUnaryPrefixExpression(Token token) {
+    assert(checkState(token, <ValueKind>[
+      unionOfKinds(<ValueKind>[
+        ValueKind.Expression,
+        ValueKind.Generator,
+      ]),
+    ]));
     debugEvent("UnaryPrefixExpression");
     Object receiver = pop();
     if (optional("!", token)) {
       push(forest.createNot(offsetForToken(token), toValue(receiver)));
     } else {
       String operator = token.stringValue;
-      Expression receiverValue;
       if (optional("-", token)) {
         operator = "unary-";
       }
-      bool isSuper = false;
-      if (receiver is ThisAccessGenerator && receiver.isSuper) {
-        isSuper = true;
-        receiverValue = forest.createThisExpression(receiver.fileOffset);
+      int fileOffset = offsetForToken(token);
+      Name name = new Name(operator);
+      if (receiver is ExplicitExtensionAccessGenerator) {
+        // TODO(johnniwinther): Use this code path for all generators. Currently
+        // TypeUseGenerator starts complaining about `-Map` not being a method
+        // instead of `unary-` not defined on `Type`.
+        push(receiver.buildPropertyAccess(
+            new SendAccessGenerator(
+                this, token, name, forest.createArgumentsEmpty(fileOffset),
+                isPotentiallyConstant: true),
+            fileOffset,
+            false));
       } else {
-        receiverValue = toValue(receiver);
+        bool isSuper = false;
+        Expression receiverValue;
+        if (receiver is ThisAccessGenerator && receiver.isSuper) {
+          ThisAccessGenerator thisAccessorReceiver = receiver;
+          isSuper = true;
+          receiverValue =
+              forest.createThisExpression(thisAccessorReceiver.fileOffset);
+        } else {
+          receiverValue = toValue(receiver);
+        }
+        push(buildMethodInvocation(receiverValue, name,
+            forest.createArgumentsEmpty(fileOffset), fileOffset,
+            // This *could* be a constant expression, we can't know without
+            // evaluating [receiver].
+            isConstantExpression: !isSuper,
+            isSuper: isSuper));
       }
-      push(buildMethodInvocation(receiverValue, new Name(operator),
-          forest.createArgumentsEmpty(noLocation), token.charOffset,
-          // This *could* be a constant expression, we can't know without
-          // evaluating [receiver].
-          isConstantExpression: !isSuper,
-          isSuper: isSuper));
     }
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart b/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
index 05fc8ed..9840652 100644
--- a/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/expression_generator.dart
@@ -14,6 +14,7 @@
 import '../builder/builder.dart';
 import '../builder/declaration_builder.dart';
 import '../builder/extension_builder.dart';
+import '../builder/function_builder.dart';
 import '../builder/invalid_type_declaration_builder.dart';
 import '../builder/member_builder.dart';
 import '../builder/named_type_builder.dart';
@@ -230,7 +231,8 @@
     if (send is SendAccessGenerator) {
       return _helper.buildMethodInvocation(buildSimpleRead(), send.name,
           send.arguments, offsetForToken(send.token),
-          isNullAware: isNullAware);
+          isNullAware: isNullAware,
+          isConstantExpression: send.isPotentiallyConstant);
     } else {
       if (_helper.constantContext != ConstantContext.none &&
           send.name != lengthName) {
@@ -1645,7 +1647,8 @@
       this.extensionThis,
       this.extensionTypeParameters)
       : assert(targetName != null),
-        assert(readTarget != null || writeTarget != null),
+        assert(
+            readTarget != null || invokeTarget != null || writeTarget != null),
         assert(extensionThis != null),
         super(helper, token);
 
@@ -1682,6 +1685,9 @@
         MemberBuilder procedureBuilder = getterBuilder;
         readTarget = procedureBuilder.extensionTearOff;
         invokeTarget = procedureBuilder.procedure;
+      } else if (getterBuilder is FunctionBuilder && getterBuilder.isOperator) {
+        assert(!getterBuilder.isStatic);
+        invokeTarget = getterBuilder.target;
       }
     }
     Procedure writeTarget;
@@ -1956,7 +1962,8 @@
       this.extensionTypeParameterCount,
       {this.isNullAware})
       : assert(targetName != null),
-        assert(readTarget != null || writeTarget != null),
+        assert(
+            readTarget != null || invokeTarget != null || writeTarget != null),
         assert(receiver != null),
         assert(isNullAware != null),
         super(helper, token);
@@ -1995,6 +2002,11 @@
         readTarget = procedureBuilder.extensionTearOff;
         invokeTarget = procedureBuilder.procedure;
         targetName = procedureBuilder.name;
+      } else if (getterBuilder is FunctionBuilder && getterBuilder.isOperator) {
+        assert(!getterBuilder.isStatic);
+        MemberBuilder memberBuilder = getterBuilder;
+        invokeTarget = memberBuilder.member;
+        targetName = memberBuilder.name;
       } else {
         return unhandled(
             "${getterBuilder.runtimeType}",
@@ -4386,8 +4398,11 @@
   @override
   final Arguments arguments;
 
+  final bool isPotentiallyConstant;
+
   SendAccessGenerator(
-      ExpressionGeneratorHelper helper, Token token, this.name, this.arguments)
+      ExpressionGeneratorHelper helper, Token token, this.name, this.arguments,
+      {this.isPotentiallyConstant: false})
       : super(helper, token) {
     assert(arguments != null);
   }
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
index 35f613a..af09eba 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
@@ -1838,7 +1838,7 @@
             receiverType != null,
             "No receiver type provided for implicit extension member "
             "invocation.");
-        inferredType = receiverType;
+        return;
       } else {
         ExpressionInferenceResult result = inferExpression(
             expression,
diff --git a/pkg/front_end/test/spell_checking_list_common.txt b/pkg/front_end/test/spell_checking_list_common.txt
index 58d08a6..188bf4d 100644
--- a/pkg/front_end/test/spell_checking_list_common.txt
+++ b/pkg/front_end/test/spell_checking_list_common.txt
@@ -484,6 +484,7 @@
 compiles
 compiling
 complain
+complaining
 complete
 completed
 completely
@@ -1168,6 +1169,7 @@
 generating
 generative
 generator
+generators
 generic
 generics
 get
diff --git a/pkg/front_end/testcases/extensions/issue38915.dart b/pkg/front_end/testcases/extensions/issue38915.dart
new file mode 100644
index 0000000..5d4752d
--- /dev/null
+++ b/pkg/front_end/testcases/extensions/issue38915.dart
@@ -0,0 +1,32 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+class Class {}
+
+extension Extension on Class {
+  void method1({bool b = false, String s = ', '}) => null;
+  void method2([bool b = false, String s = ', ']) => null;
+  void method3(int i, {bool b = false, String s = ', '}) {}
+  void method4(int i, [bool b = false, String s = ', ']) {}
+}
+
+main() {
+  var c = new Class();
+  c.method1();
+  c.method1(s: 'foo');
+  c.method1(b: true);
+  c.method1(b: true, s: 'foo');
+  c.method1(s: 'foo', b: true);
+  c.method2();
+  c.method2(true);
+  c.method2(true, 'foo');
+  c.method3(42);
+  c.method3(42, s: 'foo');
+  c.method3(42, b: true);
+  c.method3(42, b: true, s: 'foo');
+  c.method3(42, s: 'foo', b: true);
+  c.method4(42);
+  c.method4(42, true);
+  c.method4(42, true, 'foo');
+}
diff --git a/pkg/front_end/testcases/extensions/issue38915.dart.outline.expect b/pkg/front_end/testcases/extensions/issue38915.dart.outline.expect
new file mode 100644
index 0000000..56b644e
--- /dev/null
+++ b/pkg/front_end/testcases/extensions/issue38915.dart.outline.expect
@@ -0,0 +1,36 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class Class extends core::Object {
+  synthetic constructor •() → self::Class*
+    ;
+}
+extension Extension on self::Class* {
+  method method1 = self::Extension|method1;
+  tearoff method1 = self::Extension|get#method1;
+  method method2 = self::Extension|method2;
+  tearoff method2 = self::Extension|get#method2;
+  method method3 = self::Extension|method3;
+  tearoff method3 = self::Extension|get#method3;
+  method method4 = self::Extension|method4;
+  tearoff method4 = self::Extension|get#method4;
+}
+static method Extension|method1(final self::Class* #this, {core::bool* b, core::String* s}) → void
+  ;
+static method Extension|get#method1(final self::Class* #this) → ({b: core::bool*, s: core::String*}) →* void
+  return ({core::bool* b, core::String* s}) → void => self::Extension|method1(#this, b: b, s: s);
+static method Extension|method2(final self::Class* #this, [core::bool* b, core::String* s]) → void
+  ;
+static method Extension|get#method2(final self::Class* #this) → ([core::bool*, core::String*]) →* void
+  return ([core::bool* b, core::String* s]) → void => self::Extension|method2(#this, b, s);
+static method Extension|method3(final self::Class* #this, core::int* i, {core::bool* b, core::String* s}) → void
+  ;
+static method Extension|get#method3(final self::Class* #this) → (core::int*, {b: core::bool*, s: core::String*}) →* void
+  return (core::int* i, {core::bool* b, core::String* s}) → void => self::Extension|method3(#this, i, b: b, s: s);
+static method Extension|method4(final self::Class* #this, core::int* i, [core::bool* b, core::String* s]) → void
+  ;
+static method Extension|get#method4(final self::Class* #this) → (core::int*, [core::bool*, core::String*]) →* void
+  return (core::int* i, [core::bool* b, core::String* s]) → void => self::Extension|method4(#this, i, b, s);
+static method main() → dynamic
+  ;
diff --git a/pkg/front_end/testcases/extensions/issue38915.dart.strong.expect b/pkg/front_end/testcases/extensions/issue38915.dart.strong.expect
new file mode 100644
index 0000000..fdc8d05
--- /dev/null
+++ b/pkg/front_end/testcases/extensions/issue38915.dart.strong.expect
@@ -0,0 +1,57 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class Class extends core::Object {
+  synthetic constructor •() → self::Class*
+    : super core::Object::•()
+    ;
+}
+extension Extension on self::Class* {
+  method method1 = self::Extension|method1;
+  tearoff method1 = self::Extension|get#method1;
+  method method2 = self::Extension|method2;
+  tearoff method2 = self::Extension|get#method2;
+  method method3 = self::Extension|method3;
+  tearoff method3 = self::Extension|get#method3;
+  method method4 = self::Extension|method4;
+  tearoff method4 = self::Extension|get#method4;
+}
+static method Extension|method1(final self::Class* #this, {core::bool* b = #C1, core::String* s = #C2}) → void
+  return null;
+static method Extension|get#method1(final self::Class* #this) → ({b: core::bool*, s: core::String*}) →* void
+  return ({core::bool* b = #C1, core::String* s = #C2}) → void => self::Extension|method1(#this, b: b, s: s);
+static method Extension|method2(final self::Class* #this, [core::bool* b = #C1, core::String* s = #C2]) → void
+  return null;
+static method Extension|get#method2(final self::Class* #this) → ([core::bool*, core::String*]) →* void
+  return ([core::bool* b = #C1, core::String* s = #C2]) → void => self::Extension|method2(#this, b, s);
+static method Extension|method3(final self::Class* #this, core::int* i, {core::bool* b = #C1, core::String* s = #C2}) → void {}
+static method Extension|get#method3(final self::Class* #this) → (core::int*, {b: core::bool*, s: core::String*}) →* void
+  return (core::int* i, {core::bool* b = #C1, core::String* s = #C2}) → void => self::Extension|method3(#this, i, b: b, s: s);
+static method Extension|method4(final self::Class* #this, core::int* i, [core::bool* b = #C1, core::String* s = #C2]) → void {}
+static method Extension|get#method4(final self::Class* #this) → (core::int*, [core::bool*, core::String*]) →* void
+  return (core::int* i, [core::bool* b = #C1, core::String* s = #C2]) → void => self::Extension|method4(#this, i, b, s);
+static method main() → dynamic {
+  self::Class* c = new self::Class::•();
+  self::Extension|method1(c);
+  self::Extension|method1(c, s: "foo");
+  self::Extension|method1(c, b: true);
+  self::Extension|method1(c, b: true, s: "foo");
+  self::Extension|method1(c, s: "foo", b: true);
+  self::Extension|method2(c);
+  self::Extension|method2(c, true);
+  self::Extension|method2(c, true, "foo");
+  self::Extension|method3(c, 42);
+  self::Extension|method3(c, 42, s: "foo");
+  self::Extension|method3(c, 42, b: true);
+  self::Extension|method3(c, 42, b: true, s: "foo");
+  self::Extension|method3(c, 42, s: "foo", b: true);
+  self::Extension|method4(c, 42);
+  self::Extension|method4(c, 42, true);
+  self::Extension|method4(c, 42, true, "foo");
+}
+
+constants  {
+  #C1 = false
+  #C2 = ", "
+}
diff --git a/pkg/front_end/testcases/extensions/issue38915.dart.strong.transformed.expect b/pkg/front_end/testcases/extensions/issue38915.dart.strong.transformed.expect
new file mode 100644
index 0000000..fdc8d05
--- /dev/null
+++ b/pkg/front_end/testcases/extensions/issue38915.dart.strong.transformed.expect
@@ -0,0 +1,57 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class Class extends core::Object {
+  synthetic constructor •() → self::Class*
+    : super core::Object::•()
+    ;
+}
+extension Extension on self::Class* {
+  method method1 = self::Extension|method1;
+  tearoff method1 = self::Extension|get#method1;
+  method method2 = self::Extension|method2;
+  tearoff method2 = self::Extension|get#method2;
+  method method3 = self::Extension|method3;
+  tearoff method3 = self::Extension|get#method3;
+  method method4 = self::Extension|method4;
+  tearoff method4 = self::Extension|get#method4;
+}
+static method Extension|method1(final self::Class* #this, {core::bool* b = #C1, core::String* s = #C2}) → void
+  return null;
+static method Extension|get#method1(final self::Class* #this) → ({b: core::bool*, s: core::String*}) →* void
+  return ({core::bool* b = #C1, core::String* s = #C2}) → void => self::Extension|method1(#this, b: b, s: s);
+static method Extension|method2(final self::Class* #this, [core::bool* b = #C1, core::String* s = #C2]) → void
+  return null;
+static method Extension|get#method2(final self::Class* #this) → ([core::bool*, core::String*]) →* void
+  return ([core::bool* b = #C1, core::String* s = #C2]) → void => self::Extension|method2(#this, b, s);
+static method Extension|method3(final self::Class* #this, core::int* i, {core::bool* b = #C1, core::String* s = #C2}) → void {}
+static method Extension|get#method3(final self::Class* #this) → (core::int*, {b: core::bool*, s: core::String*}) →* void
+  return (core::int* i, {core::bool* b = #C1, core::String* s = #C2}) → void => self::Extension|method3(#this, i, b: b, s: s);
+static method Extension|method4(final self::Class* #this, core::int* i, [core::bool* b = #C1, core::String* s = #C2]) → void {}
+static method Extension|get#method4(final self::Class* #this) → (core::int*, [core::bool*, core::String*]) →* void
+  return (core::int* i, [core::bool* b = #C1, core::String* s = #C2]) → void => self::Extension|method4(#this, i, b, s);
+static method main() → dynamic {
+  self::Class* c = new self::Class::•();
+  self::Extension|method1(c);
+  self::Extension|method1(c, s: "foo");
+  self::Extension|method1(c, b: true);
+  self::Extension|method1(c, b: true, s: "foo");
+  self::Extension|method1(c, s: "foo", b: true);
+  self::Extension|method2(c);
+  self::Extension|method2(c, true);
+  self::Extension|method2(c, true, "foo");
+  self::Extension|method3(c, 42);
+  self::Extension|method3(c, 42, s: "foo");
+  self::Extension|method3(c, 42, b: true);
+  self::Extension|method3(c, 42, b: true, s: "foo");
+  self::Extension|method3(c, 42, s: "foo", b: true);
+  self::Extension|method4(c, 42);
+  self::Extension|method4(c, 42, true);
+  self::Extension|method4(c, 42, true, "foo");
+}
+
+constants  {
+  #C1 = false
+  #C2 = ", "
+}
diff --git a/pkg/front_end/testcases/extensions/operators.dart b/pkg/front_end/testcases/extensions/operators.dart
index cbb3b41..6927bfe 100644
--- a/pkg/front_end/testcases/extensions/operators.dart
+++ b/pkg/front_end/testcases/extensions/operators.dart
@@ -39,6 +39,11 @@
 }
 
 main() {
+  implicit();
+  explicit();
+}
+
+implicit() {
   Complex c_m2 = new Complex(-2, 2);
   Complex c_m1 = new Complex(-1, 1);
   Complex c0 = new Complex(0, 0);
@@ -77,8 +82,47 @@
   expect(c0, -c0);
 }
 
+explicit() {
+  Complex c_m2 = new Complex(-2, 2);
+  Complex c_m1 = new Complex(-1, 1);
+  Complex c0 = new Complex(0, 0);
+  Complex c1 = new Complex(1, -1);
+  Complex c2 = new Complex(2, -2);
+
+  expect(c_m2, Operators(c0) + c_m2);
+  expect(c_m2, Operators(c_m2) + c0);
+  expect(c_m2, Operators(c_m1) + c_m1);
+  expect(c_m1, Operators(c0) + c_m1);
+  expect(c_m1, Operators(c_m1) + c0);
+  expect(c0, Operators(c_m2) + c2);
+  expect(c0, Operators(c2) + c_m2);
+  expect(c0, Operators(c_m1) + c1);
+  expect(c0, Operators(c1) + c_m1);
+  expect(c0, Operators(c0) + c0);
+  expect(c1, Operators(c0) + c1);
+  expect(c1, Operators(c1) + c0);
+  expect(c2, Operators(c0) + c2);
+  expect(c2, Operators(c2) + c0);
+  expect(c2, Operators(c1) + c1);
+
+  expect(c_m2, Operators(c0) - c2);
+  expect(c2, Operators(c2) - c0);
+  expect(c_m2, -Operators(c2));
+  expect(c_m1, Operators(c1) - c2);
+  expect(c1, Operators(c2) - c1);
+  expect(c_m1, Operators(c0) - c1);
+  expect(c1, Operators(c1) - c0);
+  expect(c_m1, -Operators(c1));
+  expect(c0, Operators(c2) - c2);
+  expect(c0, Operators(c1) - c1);
+  expect(c0, Operators(c0) - c0);
+  expect(c0, Operators(c_m1) - c_m1);
+  expect(c0, Operators(c_m2) - c_m2);
+  expect(c0, -c0);
+}
+
 expect(expected, actual) {
   if (expected != actual) {
     throw 'Mismatch: expected=$expected, actual=$actual';
   }
-}
\ No newline at end of file
+}
diff --git a/pkg/front_end/testcases/extensions/operators.dart.outline.expect b/pkg/front_end/testcases/extensions/operators.dart.outline.expect
index bfa897a..c38c397 100644
--- a/pkg/front_end/testcases/extensions/operators.dart.outline.expect
+++ b/pkg/front_end/testcases/extensions/operators.dart.outline.expect
@@ -34,5 +34,9 @@
   ;
 static method main() → dynamic
   ;
+static method implicit() → dynamic
+  ;
+static method explicit() → dynamic
+  ;
 static method expect(dynamic expected, dynamic actual) → dynamic
   ;
diff --git a/pkg/front_end/testcases/extensions/operators.dart.strong.expect b/pkg/front_end/testcases/extensions/operators.dart.strong.expect
index 936cc18..3453a24 100644
--- a/pkg/front_end/testcases/extensions/operators.dart.strong.expect
+++ b/pkg/front_end/testcases/extensions/operators.dart.strong.expect
@@ -39,6 +39,46 @@
 static method Operators|unary-(final self::Complex* #this) → self::Complex*
   return #this.{self::Complex::negate}();
 static method main() → dynamic {
+  self::implicit();
+  self::explicit();
+}
+static method implicit() → dynamic {
+  self::Complex* c_m2 = new self::Complex::•(-2.0, 2.0);
+  self::Complex* c_m1 = new self::Complex::•(-1.0, 1.0);
+  self::Complex* c0 = new self::Complex::•(0.0, 0.0);
+  self::Complex* c1 = new self::Complex::•(1.0, -1.0);
+  self::Complex* c2 = new self::Complex::•(2.0, -2.0);
+  self::expect(c_m2, self::Operators|+(c0, c_m2));
+  self::expect(c_m2, self::Operators|+(c_m2, c0));
+  self::expect(c_m2, self::Operators|+(c_m1, c_m1));
+  self::expect(c_m1, self::Operators|+(c0, c_m1));
+  self::expect(c_m1, self::Operators|+(c_m1, c0));
+  self::expect(c0, self::Operators|+(c_m2, c2));
+  self::expect(c0, self::Operators|+(c2, c_m2));
+  self::expect(c0, self::Operators|+(c_m1, c1));
+  self::expect(c0, self::Operators|+(c1, c_m1));
+  self::expect(c0, self::Operators|+(c0, c0));
+  self::expect(c1, self::Operators|+(c0, c1));
+  self::expect(c1, self::Operators|+(c1, c0));
+  self::expect(c2, self::Operators|+(c0, c2));
+  self::expect(c2, self::Operators|+(c2, c0));
+  self::expect(c2, self::Operators|+(c1, c1));
+  self::expect(c_m2, self::Operators|-(c0, c2));
+  self::expect(c2, self::Operators|-(c2, c0));
+  self::expect(c_m2, self::Operators|unary-(c2));
+  self::expect(c_m1, self::Operators|-(c1, c2));
+  self::expect(c1, self::Operators|-(c2, c1));
+  self::expect(c_m1, self::Operators|-(c0, c1));
+  self::expect(c1, self::Operators|-(c1, c0));
+  self::expect(c_m1, self::Operators|unary-(c1));
+  self::expect(c0, self::Operators|-(c2, c2));
+  self::expect(c0, self::Operators|-(c1, c1));
+  self::expect(c0, self::Operators|-(c0, c0));
+  self::expect(c0, self::Operators|-(c_m1, c_m1));
+  self::expect(c0, self::Operators|-(c_m2, c_m2));
+  self::expect(c0, self::Operators|unary-(c0));
+}
+static method explicit() → dynamic {
   self::Complex* c_m2 = new self::Complex::•(-2.0, 2.0);
   self::Complex* c_m1 = new self::Complex::•(-1.0, 1.0);
   self::Complex* c0 = new self::Complex::•(0.0, 0.0);
diff --git a/pkg/front_end/testcases/extensions/operators.dart.strong.transformed.expect b/pkg/front_end/testcases/extensions/operators.dart.strong.transformed.expect
index 936cc18..3453a24 100644
--- a/pkg/front_end/testcases/extensions/operators.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/extensions/operators.dart.strong.transformed.expect
@@ -39,6 +39,46 @@
 static method Operators|unary-(final self::Complex* #this) → self::Complex*
   return #this.{self::Complex::negate}();
 static method main() → dynamic {
+  self::implicit();
+  self::explicit();
+}
+static method implicit() → dynamic {
+  self::Complex* c_m2 = new self::Complex::•(-2.0, 2.0);
+  self::Complex* c_m1 = new self::Complex::•(-1.0, 1.0);
+  self::Complex* c0 = new self::Complex::•(0.0, 0.0);
+  self::Complex* c1 = new self::Complex::•(1.0, -1.0);
+  self::Complex* c2 = new self::Complex::•(2.0, -2.0);
+  self::expect(c_m2, self::Operators|+(c0, c_m2));
+  self::expect(c_m2, self::Operators|+(c_m2, c0));
+  self::expect(c_m2, self::Operators|+(c_m1, c_m1));
+  self::expect(c_m1, self::Operators|+(c0, c_m1));
+  self::expect(c_m1, self::Operators|+(c_m1, c0));
+  self::expect(c0, self::Operators|+(c_m2, c2));
+  self::expect(c0, self::Operators|+(c2, c_m2));
+  self::expect(c0, self::Operators|+(c_m1, c1));
+  self::expect(c0, self::Operators|+(c1, c_m1));
+  self::expect(c0, self::Operators|+(c0, c0));
+  self::expect(c1, self::Operators|+(c0, c1));
+  self::expect(c1, self::Operators|+(c1, c0));
+  self::expect(c2, self::Operators|+(c0, c2));
+  self::expect(c2, self::Operators|+(c2, c0));
+  self::expect(c2, self::Operators|+(c1, c1));
+  self::expect(c_m2, self::Operators|-(c0, c2));
+  self::expect(c2, self::Operators|-(c2, c0));
+  self::expect(c_m2, self::Operators|unary-(c2));
+  self::expect(c_m1, self::Operators|-(c1, c2));
+  self::expect(c1, self::Operators|-(c2, c1));
+  self::expect(c_m1, self::Operators|-(c0, c1));
+  self::expect(c1, self::Operators|-(c1, c0));
+  self::expect(c_m1, self::Operators|unary-(c1));
+  self::expect(c0, self::Operators|-(c2, c2));
+  self::expect(c0, self::Operators|-(c1, c1));
+  self::expect(c0, self::Operators|-(c0, c0));
+  self::expect(c0, self::Operators|-(c_m1, c_m1));
+  self::expect(c0, self::Operators|-(c_m2, c_m2));
+  self::expect(c0, self::Operators|unary-(c0));
+}
+static method explicit() → dynamic {
   self::Complex* c_m2 = new self::Complex::•(-2.0, 2.0);
   self::Complex* c_m1 = new self::Complex::•(-1.0, 1.0);
   self::Complex* c0 = new self::Complex::•(0.0, 0.0);
diff --git a/pkg/front_end/testcases/text_serialization.status b/pkg/front_end/testcases/text_serialization.status
index c15719f..d617f89 100644
--- a/pkg/front_end/testcases/text_serialization.status
+++ b/pkg/front_end/testcases/text_serialization.status
@@ -47,6 +47,7 @@
 extensions/issue38745: TextSerializationFailure
 extensions/issue38750: TextSerializationFailure
 extensions/issue38755: TextSerializationFailure
+extensions/issue38915: TextSerializationFailure
 extensions/nested_on_types: TextSerializationFailure
 extensions/null_aware: TextSerializationFailure
 extensions/on_function_type: TextSerializationFailure
diff --git a/pkg/vm/lib/transformations/ffi_use_sites.dart b/pkg/vm/lib/transformations/ffi_use_sites.dart
index 3cb0dfc..4bf6586 100644
--- a/pkg/vm/lib/transformations/ffi_use_sites.dart
+++ b/pkg/vm/lib/transformations/ffi_use_sites.dart
@@ -344,17 +344,18 @@
   }
 
   void _ensureNativeTypeToDartType(
-      DartType containerTypeArg, DartType elementType, Expression node,
+      DartType nativeType, DartType dartType, Expression node,
       {bool allowStructs: false}) {
-    final DartType shouldBeElementType =
-        convertNativeTypeToDartType(containerTypeArg, allowStructs);
-    if (elementType == shouldBeElementType) return;
-    // We disable implicit downcasts, they will go away when NNBD lands.
-    if (env.isSubtypeOf(elementType, shouldBeElementType,
-        SubtypeCheckMode.ignoringNullabilities)) return;
+    final DartType correspondingDartType =
+        convertNativeTypeToDartType(nativeType, allowStructs);
+    if (dartType == correspondingDartType) return;
+    if (env.isSubtypeOf(correspondingDartType, dartType,
+        SubtypeCheckMode.ignoringNullabilities)) {
+      return;
+    }
     diagnosticReporter.report(
         templateFfiTypeMismatch.withArguments(
-            elementType, shouldBeElementType, containerTypeArg),
+            dartType, correspondingDartType, nativeType),
         node.fileOffset,
         1,
         node.location.file);
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index f634d26..bde9684 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -929,6 +929,8 @@
         return !shaker.isClassUsed(node);
       } else if (node is Typedef) {
         return !shaker.isTypedefUsed(node);
+      } else if (node is Extension) {
+        return !shaker.isExtensionUsed(node);
       } else {
         return !shaker.isMemberUsed(node as Member);
       }
diff --git a/runtime/bin/ffi_test/ffi_test_functions.cc b/runtime/bin/ffi_test/ffi_test_functions.cc
index 85145b1..784093e 100644
--- a/runtime/bin/ffi_test/ffi_test_functions.cc
+++ b/runtime/bin/ffi_test/ffi_test_functions.cc
@@ -855,4 +855,31 @@
 
 #endif  // defined(TARGET_OS_LINUX)
 
+// Receives some pointer (Pointer<NativeType> in Dart) and writes some bits.
+DART_EXPORT void NativeTypePointerParam(void* p) {
+  uint8_t* p2 = reinterpret_cast<uint8_t*>(p);
+  p2[0] = 42;
+}
+
+// Manufactures some pointer (Pointer<NativeType> in Dart) with a bogus address.
+DART_EXPORT void* NativeTypePointerReturn() {
+  uint64_t bogus_address = 0x13370000;
+  return reinterpret_cast<void*>(bogus_address);
+}
+
+// Passes some pointer (Pointer<NativeType> in Dart) to Dart as argument.
+DART_EXPORT void CallbackNativeTypePointerParam(void (*f)(void*)) {
+  void* pointer = malloc(sizeof(int64_t));
+  f(pointer);
+  free(pointer);
+}
+
+// Receives some pointer (Pointer<NativeType> in Dart) from Dart as return
+// value.
+DART_EXPORT void CallbackNativeTypePointerReturn(void* (*f)()) {
+  void* p = f();
+  uint8_t* p2 = reinterpret_cast<uint8_t*>(p);
+  p2[0] = 42;
+}
+
 }  // namespace dart
diff --git a/runtime/bin/file_android.cc b/runtime/bin/file_android.cc
index 6fa50ad..681c46f 100644
--- a/runtime/bin/file_android.cc
+++ b/runtime/bin/file_android.cc
@@ -597,11 +597,16 @@
     errno = ENOENT;
     return -1;
   }
-  const size_t target_size =
+  size_t target_size =
       TEMP_FAILURE_RETRY(readlink(pathname, result, result_size));
   if (target_size <= 0) {
     return -1;
   }
+  // readlink returns non-zero terminated strings. Append.
+  if (target_size < result_size) {
+    result[target_size] = '\0';
+    target_size++;
+  }
   return target_size;
 }
 
@@ -615,10 +620,9 @@
   if (target_size <= 0) {
     return NULL;
   }
-  char* target_name = DartUtils::ScopedCString(target_size + 1);
+  char* target_name = DartUtils::ScopedCString(target_size);
   ASSERT(target_name != NULL);
   memmove(target_name, target, target_size);
-  target_name[target_size] = '\0';
   return target_name;
 }
 
diff --git a/runtime/bin/file_linux.cc b/runtime/bin/file_linux.cc
index 190b195..e478173 100644
--- a/runtime/bin/file_linux.cc
+++ b/runtime/bin/file_linux.cc
@@ -590,11 +590,16 @@
     errno = ENOENT;
     return -1;
   }
-  const size_t target_size =
+  size_t target_size =
       TEMP_FAILURE_RETRY(readlink(pathname, result, result_size));
   if (target_size <= 0) {
     return -1;
   }
+  // readlink returns non-zero terminated strings. Append.
+  if (target_size < result_size) {
+    result[target_size] = '\0';
+    target_size++;
+  }
   return target_size;
 }
 
@@ -608,10 +613,9 @@
   if (target_size <= 0) {
     return NULL;
   }
-  char* target_name = DartUtils::ScopedCString(target_size + 1);
+  char* target_name = DartUtils::ScopedCString(target_size);
   ASSERT(target_name != NULL);
   memmove(target_name, target, target_size);
-  target_name[target_size] = '\0';
   return target_name;
 }
 
diff --git a/runtime/bin/main.cc b/runtime/bin/main.cc
index fbc69b3..8e76803 100644
--- a/runtime/bin/main.cc
+++ b/runtime/bin/main.cc
@@ -1088,16 +1088,21 @@
   // snapshot, load and run that.
   // Any arguments passed to such an executable are meant for the actual
   // application so skip all Dart VM flag parsing.
-  app_snapshot = Snapshot::TryReadAppendedAppSnapshotElf(argv[0]);
-  if (app_snapshot != nullptr) {
-    script_name = argv[0];
 
-    // Store the executable name.
-    Platform::SetExecutableName(argv[0]);
+  const size_t kPathBufSize = PATH_MAX + 1;
+  char executable_path[kPathBufSize];
+  if (Platform::ResolveExecutablePathInto(executable_path, kPathBufSize) > 0) {
+    app_snapshot = Snapshot::TryReadAppendedAppSnapshotElf(executable_path);
+    if (app_snapshot != nullptr) {
+      script_name = argv[0];
 
-    // Parse out options to be passed to dart main.
-    for (int i = 1; i < argc; i++) {
-      dart_options.AddArgument(argv[i]);
+      // Store the executable name.
+      Platform::SetExecutableName(argv[0]);
+
+      // Parse out options to be passed to dart main.
+      for (int i = 1; i < argc; i++) {
+        dart_options.AddArgument(argv[i]);
+      }
     }
   }
 #endif
diff --git a/runtime/bin/platform.h b/runtime/bin/platform.h
index b0b3aa2..50b9a10 100644
--- a/runtime/bin/platform.h
+++ b/runtime/bin/platform.h
@@ -64,13 +64,12 @@
 
   static const char* ResolveExecutablePath();
 
-  // On Linux and Android this has the same effect as calling
-  // ResolveExecutablePath except that Dart_ScopeAllocate is not called and that
-  // the result goes into the given parameters.
-  // On all other platforms it returns -1, i.e. doesn't work.
+  // This has the same effect as calling ResolveExecutablePath except that
+  // Dart_ScopeAllocate is not called and that the result goes into the given
+  // parameters.
+  // WARNING: On Fuchsia it returns -1, i.e. doesn't work.
   // Note that `result` should be pre-allocated with size `result_size`.
   // The return-value is the length read into `result` or -1 on failure.
-  // The content of `result` is not guranteed to be null-terminated.
   static intptr_t ResolveExecutablePathInto(char* result, size_t result_size);
 
   // Stores the executable name.
diff --git a/runtime/bin/platform_macos.cc b/runtime/bin/platform_macos.cc
index 2be3f30..bacb7a75 100644
--- a/runtime/bin/platform_macos.cc
+++ b/runtime/bin/platform_macos.cc
@@ -252,7 +252,18 @@
 }
 
 intptr_t Platform::ResolveExecutablePathInto(char* result, size_t result_size) {
-  return -1;
+  // Get the required length of the buffer.
+  uint32_t path_size = 0;
+  if (_NSGetExecutablePath(nullptr, &path_size) == 0) {
+    return -1;
+  }
+  if (path_size > result_size) {
+    return -1;
+  }
+  if (_NSGetExecutablePath(result, &path_size) != 0) {
+    return -1;
+  }
+  return path_size;
 }
 
 void Platform::Exit(int exit_code) {
diff --git a/runtime/bin/platform_win.cc b/runtime/bin/platform_win.cc
index e4f20a2..552e3c2 100644
--- a/runtime/bin/platform_win.cc
+++ b/runtime/bin/platform_win.cc
@@ -275,7 +275,7 @@
   // Ensure no last error before calling GetModuleFileNameW.
   SetLastError(ERROR_SUCCESS);
   // Get the required length of the buffer.
-  int path_length = GetModuleFileNameW(NULL, tmp_buffer, kTmpBufferSize);
+  GetModuleFileNameW(nullptr, tmp_buffer, kTmpBufferSize);
   if (GetLastError() != ERROR_SUCCESS) {
     return NULL;
   }
@@ -286,6 +286,20 @@
 }
 
 intptr_t Platform::ResolveExecutablePathInto(char* result, size_t result_size) {
+  // Ensure no last error before calling GetModuleFileNameW.
+  SetLastError(ERROR_SUCCESS);
+  const int kTmpBufferSize = 32768;
+  wchar_t tmp_buffer[kTmpBufferSize];
+  // Get the required length of the buffer.
+  GetModuleFileNameW(nullptr, tmp_buffer, kTmpBufferSize);
+  if (GetLastError() != ERROR_SUCCESS) {
+    return -1;
+  }
+  WideToUtf8Scope wide_to_utf8_scope(tmp_buffer);
+  if (wide_to_utf8_scope.length() <= result_size) {
+    strncpy(result, wide_to_utf8_scope.utf8(), result_size);
+    return wide_to_utf8_scope.length();
+  }
   return -1;
 }
 
diff --git a/runtime/platform/globals.h b/runtime/platform/globals.h
index 2dd7547..d754abf 100644
--- a/runtime/platform/globals.h
+++ b/runtime/platform/globals.h
@@ -722,6 +722,11 @@
 #define STDERR_FILENO 2
 #endif
 
+#ifndef PATH_MAX
+// Most platforms use PATH_MAX, but in Windows it's called MAX_PATH.
+#define PATH_MAX MAX_PATH
+#endif
+
 }  // namespace dart
 
 #endif  // RUNTIME_PLATFORM_GLOBALS_H_
diff --git a/runtime/tests/vm/dart/run_appended_aot_snapshot_test.dart b/runtime/tests/vm/dart/run_appended_aot_snapshot_test.dart
index 1594605..26b7a9c 100644
--- a/runtime/tests/vm/dart/run_appended_aot_snapshot_test.dart
+++ b/runtime/tests/vm/dart/run_appended_aot_snapshot_test.dart
@@ -22,9 +22,10 @@
       'runtime', 'tests', 'vm', 'dart', 'run_appended_aot_snapshot_test.dart');
 
   await withTempDir((String tmp) async {
+    final String exeName = 'test.exe';
     final String dillPath = path.join(tmp, 'test.dill');
     final String aotPath = path.join(tmp, 'test.aot');
-    final String exePath = path.join(tmp, 'test.exe');
+    final String exePath = path.join(tmp, exeName);
 
     {
       final result = await generateAotKernel(checkedInDartVM, genKernel,
@@ -51,8 +52,33 @@
       Expect.equals(result.stdout, '');
     }
 
-    final runResult =
-        await runBinary('run appended aot snapshot', exePath, ['--child']);
-    expectOutput('Hello, Appended AOT', runResult);
+    {
+      final runResult =
+          await runBinary('run appended aot snapshot', exePath, ['--child']);
+      expectOutput('Hello, Appended AOT', runResult);
+    }
+
+    {
+      // Test that it runs when invoked via PATH as well.
+      Map<String, String> environment = {'PATH': tmp};
+      final runResult = await runBinary(
+          'run appended aot snapshot from PATH', exeName, ['--child'],
+          environment: environment, runInShell: true);
+      expectOutput('Hello, Appended AOT', runResult);
+    }
+
+    // Windows allows leaving out .exe. Make sure we can load that as well.
+    if (Platform.isWindows) {
+      final String exeNameWithoutExt =
+          exeName.replaceFirst(new RegExp(r'.exe$'), '');
+      Map<String, String> environment = {'PATH': tmp};
+      final runResult = await runBinary(
+          'run appended aot snapshot without extension',
+          exeNameWithoutExt,
+          ['--child'],
+          environment: environment,
+          runInShell: true);
+      expectOutput('Hello, Appended AOT', runResult);
+    }
   });
 }
diff --git a/runtime/tests/vm/dart/snapshot_test_helper.dart b/runtime/tests/vm/dart/snapshot_test_helper.dart
index 6f42b07..8ffd309 100644
--- a/runtime/tests/vm/dart/snapshot_test_helper.dart
+++ b/runtime/tests/vm/dart/snapshot_test_helper.dart
@@ -72,10 +72,11 @@
   return runBinary(prefix, genSnapshot, arguments);
 }
 
-Future<Result> runBinary(
-    String prefix, String binary, List<String> arguments) async {
+Future<Result> runBinary(String prefix, String binary, List<String> arguments,
+    {Map<String, String> environment, bool runInShell: false}) async {
   print("+ $binary " + arguments.join(" "));
-  final processResult = await Process.run(binary, arguments);
+  final processResult = await Process.run(binary, arguments,
+      environment: environment, runInShell: runInShell);
   final result =
       new Result('[$prefix] ${binary} ${arguments.join(' ')}', processResult);
 
diff --git a/tests/ffi/function_test.dart b/tests/ffi/function_test.dart
index 51cc2fe..38c36a9 100644
--- a/tests/ffi/function_test.dart
+++ b/tests/ffi/function_test.dart
@@ -13,8 +13,6 @@
 // VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
 // SharedObjects=ffi_test_functions
 
-library FfiTest;
-
 import 'dart:ffi';
 
 import 'dylib_utils.dart';
@@ -44,6 +42,7 @@
     testVoidReturn();
     testNoArgs();
     testException();
+    testLookupFunctionPointerNativeType();
   }
 }
 
@@ -405,6 +404,17 @@
   Expect.approxEquals(1337.0, result);
 }
 
+typedef NativeTypeNFT = Pointer<NativeType> Function(
+    Pointer<Pointer<NativeType>>, Int8);
+typedef NativeTypeFT = Pointer<NativeType> Function(
+    Pointer<Pointer<NativeType>>, int);
+
+void testLookupFunctionPointerNativeType() {
+  // The function signature does not match up, but that does not matter since
+  // this test does not use the trampoline.
+  ffiTestFunctions.lookupFunction<NativeTypeNFT, NativeTypeFT>("LargePointer");
+}
+
 // Throw an exception from within the trampoline and collect a stacktrace
 // include its frame.
 void testException() {
diff --git a/tests/ffi/variance_function_checks_test.dart b/tests/ffi/variance_function_checks_test.dart
new file mode 100644
index 0000000..c17488c
--- /dev/null
+++ b/tests/ffi/variance_function_checks_test.dart
@@ -0,0 +1,67 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+//
+// SharedObjects=ffi_test_functions
+
+import 'dart:ffi';
+
+import 'dylib_utils.dart';
+
+// ============================================
+// Tests checks on Dart to native (asFunction).
+// ============================================
+
+typedef Int64PointerParamOpDart = void Function(Pointer<Int64>);
+typedef Int64PointerParamOp = Void Function(Pointer<Int64>);
+typedef Int64PointerReturnOp = Pointer<Int64> Function();
+typedef NaTyPointerReturnOp = Pointer<NativeType> Function();
+
+final paramOpName = "NativeTypePointerParam";
+final returnOpName = "NativeTypePointerReturn";
+
+final DynamicLibrary ffiTestFunctions =
+    dlopenPlatformSpecific("ffi_test_functions");
+
+final p1 =
+    ffiTestFunctions.lookup<NativeFunction<Int64PointerParamOp>>(paramOpName);
+final nonInvariantBinding1 = //# 1:  compile-time error
+    p1.asFunction<NaTyPointerParamOpDart>(); //# 1:  continued
+
+final p2 =
+    ffiTestFunctions.lookup<NativeFunction<NaTyPointerReturnOp>>(returnOpName);
+final nonInvariantBinding2 = //# 2:  compile-time error
+    p2.asFunction<Int64PointerReturnOp>(); //# 2:  continued
+
+final p3 = Pointer<
+    NativeFunction<
+        Pointer<NativeFunction<Pointer<NativeType> Function()>>
+            Function()>>.fromAddress(0x1234);
+final f3 = p3 //# 10:  compile-time error
+    .asFunction< //# 10:  continued
+        Pointer< //# 10:  continued
+                NativeFunction< //# 10:  continued
+                    Pointer<Int8> Function()>> //# 10:  continued
+            Function()>(); //# 10:  continued
+
+// ===========================================================
+// Test check on callbacks from native to Dart (fromFunction).
+// ===========================================================
+
+void naTyPointerParamOp(Pointer<NativeType> p) {
+  final Pointer<Int8> asInt8 = p.cast();
+  asInt8.value = 42;
+}
+
+Pointer<Int64> int64PointerReturnOp() {
+  return Pointer.fromAddress(0x13370000);
+}
+
+final implictDowncast1 = //# 3:  compile-time error
+    Pointer.fromFunction<Int64PointerParamOp>(//# 3:  continued
+        naTyPointerParamOp); //# 3:  continued
+final implictDowncast2 = //# 4:  compile-time error
+    Pointer.fromFunction<NaTyPointerReturnOp>(//# 4:  continued
+        int64PointerReturnOp); //# 4:  continued
+
+void main() {}
diff --git a/tests/ffi/variance_function_test.dart b/tests/ffi/variance_function_test.dart
new file mode 100644
index 0000000..d6e6378
--- /dev/null
+++ b/tests/ffi/variance_function_test.dart
@@ -0,0 +1,238 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+//
+// VMOptions=
+// VMOptions=--deterministic --optimization-counter-threshold=10
+// VMOptions=--use-slow-path
+// SharedObjects=ffi_test_functions
+//
+// This file tests subtyping relationships (at compile time and at runtime) of
+// parameters and return types of ffi trampolines and ffi callback trampolines.
+
+import 'dart:ffi';
+
+import 'dylib_utils.dart';
+
+import "package:expect/expect.dart";
+import "package:ffi/ffi.dart";
+
+typedef Int64PointerParamOpDart = void Function(Pointer<Int64>);
+typedef Int64PointerParamOp = Void Function(Pointer<Int64>);
+typedef NaTyPointerParamOpDart = void Function(Pointer<NativeType>);
+typedef NaTyPointerParamOp = Void Function(Pointer<NativeType>);
+typedef Int64PointerReturnOp = Pointer<Int64> Function();
+typedef NaTyPointerReturnOp = Pointer<NativeType> Function();
+
+final paramOpName = "NativeTypePointerParam";
+final returnOpName = "NativeTypePointerReturn";
+
+final DynamicLibrary ffiTestFunctions =
+    dlopenPlatformSpecific("ffi_test_functions");
+
+// =============================================
+// Tests calls from Dart to native (asFunction).
+// =============================================
+
+void paramInvariant1() {
+  final fp =
+      ffiTestFunctions.lookup<NativeFunction<Int64PointerParamOp>>(paramOpName);
+  final f = fp.asFunction<Int64PointerParamOpDart>();
+  final arg = allocate<Int64>();
+  f(arg);
+  free(arg);
+}
+
+void paramInvariant2() {
+  final fp =
+      ffiTestFunctions.lookup<NativeFunction<NaTyPointerParamOp>>(paramOpName);
+  final f = fp.asFunction<NaTyPointerParamOpDart>();
+  final arg = allocate<Int64>().cast<NativeType>();
+  Expect.type<Pointer<NativeType>>(arg);
+  f(arg);
+  free(arg);
+}
+
+// Pass a statically and dynamically subtyped argument.
+void paramSubtype1() {
+  final fp =
+      ffiTestFunctions.lookup<NativeFunction<NaTyPointerParamOp>>(paramOpName);
+  final f = fp.asFunction<NaTyPointerParamOpDart>();
+  final arg = allocate<Int64>();
+  Expect.type<Pointer<Int64>>(arg);
+  f(arg);
+  free(arg);
+}
+
+// Pass a statically subtyped but dynamically invariant argument.
+void paramSubtype2() {
+  final fp =
+      ffiTestFunctions.lookup<NativeFunction<NaTyPointerParamOp>>(paramOpName);
+  final f = fp.asFunction<NaTyPointerParamOpDart>();
+  final Pointer<NativeType> arg = allocate<Int64>();
+  Expect.type<Pointer<Int64>>(arg);
+  f(arg);
+  free(arg);
+}
+
+void returnInvariant1() {
+  final fp = ffiTestFunctions
+      .lookup<NativeFunction<Int64PointerReturnOp>>(returnOpName);
+  final f = fp.asFunction<Int64PointerReturnOp>();
+  final result = f();
+  Expect.type<Pointer<Int64>>(result);
+}
+
+void returnInvariant2() {
+  final fp = ffiTestFunctions
+      .lookup<NativeFunction<NaTyPointerReturnOp>>(returnOpName);
+  final f = fp.asFunction<NaTyPointerReturnOp>();
+  final result = f();
+  Expect.type<Pointer<NativeType>>(result);
+}
+
+void returnSubtype() {
+  final fp = ffiTestFunctions
+      .lookup<NativeFunction<Int64PointerReturnOp>>(returnOpName);
+  final f = fp.asFunction<Int64PointerReturnOp>();
+  final NaTyPointerReturnOp f2 = f;
+  Expect.type<Int64PointerReturnOp>(f2);
+  final result = f2();
+  Expect.type<Pointer<NativeType>>(result);
+}
+
+void functionArgumentVariance() {
+  final p = Pointer<
+      NativeFunction<
+          Pointer<NativeFunction<Pointer<Int8> Function(Pointer<NativeType>)>> Function(
+              Pointer<
+                  NativeFunction<
+                      Pointer<NativeType> Function(
+                          Pointer<Int8>)>>)>>.fromAddress(0x1234);
+  final f = p.asFunction<
+      Pointer<NativeFunction<Pointer<NativeType> Function(Pointer<Int8>)>> Function(
+          Pointer<
+              NativeFunction<Pointer<Int8> Function(Pointer<NativeType>)>>)>();
+}
+
+void asFunctionTests() {
+  for (int i = 0; i < 100; ++i) {
+    paramInvariant1(); // Parameter invariant: Pointer<Int64>.
+    paramInvariant2(); // Parameter invariant: Pointer<NativeType>.
+    paramSubtype1(); // Parameter statically and dynamically subtyped.
+    paramSubtype2(); // Parameter statically invariant, dynamically subtyped.
+    returnInvariant1(); // Return value invariant: Pointer<Int64>.
+    returnInvariant2(); // Return value invariant: Pointer<NativeType>.
+    returnSubtype(); // Return value static subtyped, dynamically invariant.
+    functionArgumentVariance(); // Check nested function signatures.
+  }
+}
+
+// =======================================================
+// Test with callbacks from native to Dart (fromFunction).
+// =======================================================
+
+typedef CallbackInt64PointerParamOpDart = void Function(
+    Pointer<NativeFunction<Int64PointerParamOp>>);
+typedef CallbackInt64PointerParamOp = Void Function(
+    Pointer<NativeFunction<Int64PointerParamOp>>);
+
+typedef CallbackNaTyPointerParamOpDart = void Function(
+    Pointer<NativeFunction<NaTyPointerParamOp>>);
+typedef CallbackNaTyPointerParamOp = Void Function(
+    Pointer<NativeFunction<NaTyPointerParamOp>>);
+
+typedef CallbackInt64PointerReturnOpDart = void Function(
+    Pointer<NativeFunction<Int64PointerReturnOp>>);
+typedef CallbackInt64PointerReturnOp = Void Function(
+    Pointer<NativeFunction<Int64PointerReturnOp>>);
+
+typedef CallbackNaTyPointerReturnOpDart = void Function(
+    Pointer<NativeFunction<NaTyPointerReturnOp>>);
+typedef CallbackNaTyPointerReturnOp = Void Function(
+    Pointer<NativeFunction<NaTyPointerReturnOp>>);
+
+final callbackParamOpName = "CallbackNativeTypePointerParam";
+final callbackReturnOpName = "CallbackNativeTypePointerReturn";
+
+void int64PointerParamOp(Pointer<Int64> p) {
+  p.value = 42;
+}
+
+void naTyPointerParamOp(Pointer<NativeType> p) {
+  final Pointer<Int8> asInt8 = p.cast();
+  asInt8.value = 42;
+}
+
+// Pointer to return to C when C calls back into Dart and asks for a Pointer.
+Pointer<Int64> data;
+
+Pointer<Int64> int64PointerReturnOp() {
+  return data;
+}
+
+Pointer<NativeType> naTyPointerReturnOp() {
+  return data;
+}
+
+void callbackParamInvariant1() {
+  final callback = ffiTestFunctions.lookupFunction<CallbackInt64PointerParamOp,
+      CallbackInt64PointerParamOpDart>(callbackParamOpName);
+  final fp = Pointer.fromFunction<Int64PointerParamOp>(int64PointerParamOp);
+  callback(fp);
+}
+
+void callbackParamInvariant2() {
+  final callback = ffiTestFunctions.lookupFunction<CallbackNaTyPointerParamOp,
+      CallbackNaTyPointerParamOpDart>(callbackParamOpName);
+  final fp = Pointer.fromFunction<NaTyPointerParamOp>(naTyPointerParamOp);
+  callback(fp);
+}
+
+void callbackParamImplictDowncast1() {
+  final callback = ffiTestFunctions.lookupFunction<CallbackNaTyPointerParamOp,
+      CallbackNaTyPointerParamOpDart>(callbackParamOpName);
+  final fp = Pointer.fromFunction<Int64PointerParamOp>(int64PointerParamOp);
+  Expect.throws(() {
+    callback(fp);
+  });
+}
+
+void callbackParamSubtype1() {
+  final callback = ffiTestFunctions.lookupFunction<CallbackNaTyPointerParamOp,
+      CallbackNaTyPointerParamOpDart>(callbackParamOpName);
+  final fp = Pointer.fromFunction<NaTyPointerParamOp>(int64PointerParamOp);
+  callback(fp);
+}
+
+void callbackReturnInvariant1() {
+  final callback = ffiTestFunctions.lookupFunction<CallbackInt64PointerReturnOp,
+      CallbackInt64PointerReturnOpDart>(callbackReturnOpName);
+  final fp = Pointer.fromFunction<Int64PointerReturnOp>(int64PointerReturnOp);
+  callback(fp);
+}
+
+void callbackReturnInvariant2() {
+  final callback = ffiTestFunctions.lookupFunction<CallbackNaTyPointerReturnOp,
+      CallbackNaTyPointerReturnOpDart>(callbackReturnOpName);
+  final fp = Pointer.fromFunction<NaTyPointerReturnOp>(naTyPointerReturnOp);
+  callback(fp);
+}
+
+void fromFunctionTests() {
+  data = allocate();
+  for (int i = 0; i < 100; ++i) {
+    callbackParamInvariant1(); // Pointer<Int64> invariant
+    callbackParamInvariant2(); // Pointer<NativeType> invariant
+    callbackParamImplictDowncast1(); // static and dynamically supertyped
+    callbackParamSubtype1(); // static and dynamically subtyped
+    callbackReturnInvariant1(); // Pointer<Int64> invariant
+    callbackReturnInvariant2(); // Pointer<NativeType> invariant
+  }
+  free(data);
+}
+
+void main() {
+  asFunctionTests();
+  fromFunctionTests();
+}
diff --git a/tests/language_2/vm/regress_flutter_42845_lib.dart b/tests/language_2/vm/regress_flutter_42845_lib.dart
new file mode 100644
index 0000000..f22d832
--- /dev/null
+++ b/tests/language_2/vm/regress_flutter_42845_lib.dart
@@ -0,0 +1,12 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+extension TestExtension on int {
+  bool get isPositive => this > 0;
+  bool get isNegative => this < 0;
+}
+
+extension UnusedExtension on int {
+  bool get isReallyZero => this == 0;
+}
diff --git a/tests/language_2/vm/regress_flutter_42845_test.dart b/tests/language_2/vm/regress_flutter_42845_test.dart
new file mode 100644
index 0000000..ac05e97
--- /dev/null
+++ b/tests/language_2/vm/regress_flutter_42845_test.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// SharedOptions=--enable-experiment=extension-methods
+
+// Tests exported extensions.
+
+import "regress_flutter_42845_lib.dart";
+export "regress_flutter_42845_lib.dart" show TestExtension, UnusedExtension;
+
+import "package:expect/expect.dart";
+
+int i = 42;
+
+void main() {
+  Expect.isTrue(i.isPositive);
+  Expect.isFalse(i.isNegative);
+}
diff --git a/tools/VERSION b/tools/VERSION
index 528e6b2..3393977 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -34,6 +34,6 @@
 MINOR 6
 PATCH 0
 PRERELEASE 8
-PRERELEASE_PATCH 0
+PRERELEASE_PATCH 1
 ABI_VERSION 19
 OLDEST_SUPPORTED_ABI_VERSION 18