diff --git a/pkg/nnbd_migration/lib/src/graph_builder.dart b/pkg/nnbd_migration/lib/src/graph_builder.dart
index 0bd79a9..30029c3 100644
--- a/pkg/nnbd_migration/lib/src/graph_builder.dart
+++ b/pkg/nnbd_migration/lib/src/graph_builder.dart
@@ -195,43 +195,41 @@
 
   @override
   DecoratedType visitBinaryExpression(BinaryExpression node) {
-    switch (node.operator.type) {
-      case TokenType.EQ_EQ:
-      case TokenType.BANG_EQ:
-        assert(node.leftOperand is! NullLiteral); // TODO(paulberry)
-        var leftType = node.leftOperand.accept(this);
-        node.rightOperand.accept(this);
-        if (node.rightOperand is NullLiteral) {
-          // TODO(paulberry): figure out what the rules for isPure should be.
-          // TODO(paulberry): only set falseChecksNonNull in unconditional
-          // control flow
-          bool isPure = node.leftOperand is SimpleIdentifier;
-          var conditionInfo = _ConditionInfo(node,
-              isPure: isPure,
-              trueGuard: leftType.node,
-              falseDemonstratesNonNullIntent: leftType.node);
-          _conditionInfo = node.operator.type == TokenType.EQ_EQ
-              ? conditionInfo
-              : conditionInfo.not(node);
-        }
-        return _nonNullableBoolType;
-      case TokenType.PLUS:
-        _handleAssignment(_notNullType, node.leftOperand);
-        var callee = node.staticElement;
-        assert(!(callee is ClassMemberElement &&
-            callee.enclosingElement.typeParameters
-                .isNotEmpty)); // TODO(paulberry)
-        assert(callee != null); // TODO(paulberry)
-        var calleeType = getOrComputeElementType(callee);
-        // TODO(paulberry): substitute if necessary
-        assert(calleeType.positionalParameters.length > 0); // TODO(paulberry)
-        _handleAssignment(
-            calleeType.positionalParameters[0], node.rightOperand);
-        return calleeType.returnType;
-      default:
-        // TODO(paulberry)
-        _unimplemented(
-            node, 'Binary expression with operator ${node.operator.lexeme}');
+    var operatorType = node.operator.type;
+    if (operatorType == TokenType.EQ_EQ || operatorType == TokenType.BANG_EQ) {
+      assert(node.leftOperand is! NullLiteral); // TODO(paulberry)
+      var leftType = node.leftOperand.accept(this);
+      node.rightOperand.accept(this);
+      if (node.rightOperand is NullLiteral) {
+        // TODO(paulberry): figure out what the rules for isPure should be.
+        // TODO(paulberry): only set falseChecksNonNull in unconditional
+        // control flow
+        bool isPure = node.leftOperand is SimpleIdentifier;
+        var conditionInfo = _ConditionInfo(node,
+            isPure: isPure,
+            trueGuard: leftType.node,
+            falseDemonstratesNonNullIntent: leftType.node);
+        _conditionInfo = operatorType == TokenType.EQ_EQ
+            ? conditionInfo
+            : conditionInfo.not(node);
+      }
+      return _nonNullableBoolType;
+    } else if (operatorType.isUserDefinableOperator) {
+      _handleAssignment(_notNullType, node.leftOperand);
+      var callee = node.staticElement;
+      assert(!(callee is ClassMemberElement &&
+          callee
+              .enclosingElement.typeParameters.isNotEmpty)); // TODO(paulberry)
+      assert(callee != null); // TODO(paulberry)
+      var calleeType = getOrComputeElementType(callee);
+      // TODO(paulberry): substitute if necessary
+      assert(calleeType.positionalParameters.length > 0); // TODO(paulberry)
+      _handleAssignment(calleeType.positionalParameters[0], node.rightOperand);
+      return calleeType.returnType;
+    } else {
+      // TODO(paulberry)
+      _unimplemented(
+          node, 'Binary expression with operator ${node.operator.lexeme}');
     }
   }
 
diff --git a/pkg/nnbd_migration/test/graph_builder_test.dart b/pkg/nnbd_migration/test/graph_builder_test.dart
index 71cd99b..0bc9ba1 100644
--- a/pkg/nnbd_migration/test/graph_builder_test.dart
+++ b/pkg/nnbd_migration/test/graph_builder_test.dart
@@ -286,7 +286,111 @@
     assertNoUpstreamNullability(decoratedTypeAnnotation('int').node);
   }
 
-  test_binaryExpression_add_left_check() async {
+  test_binaryExpression_ampersand_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i & j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
+  }
+
+  test_binaryExpression_bar_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i | j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
+  }
+
+  test_binaryExpression_caret_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i ^ j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
+  }
+
+  test_binaryExpression_equal() async {
+    await analyze('''
+bool f(int i, int j) => i == j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('bool f').node);
+  }
+
+  test_binaryExpression_gt_result_not_null() async {
+    await analyze('''
+bool f(int i, int j) => i > j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('bool f').node);
+  }
+
+  test_binaryExpression_gtEq_result_not_null() async {
+    await analyze('''
+bool f(int i, int j) => i >= j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('bool f').node);
+  }
+
+  test_binaryExpression_gtGt_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i >> j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
+  }
+
+  test_binaryExpression_lt_result_not_null() async {
+    await analyze('''
+bool f(int i, int j) => i < j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('bool f').node);
+  }
+
+  test_binaryExpression_ltEq_result_not_null() async {
+    await analyze('''
+bool f(int i, int j) => i <= j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('bool f').node);
+  }
+
+  test_binaryExpression_ltLt_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i << j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
+  }
+
+  test_binaryExpression_minus_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i - j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
+  }
+
+  test_binaryExpression_notEqual() async {
+    await analyze('''
+bool f(int i, int j) => i != j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('bool f').node);
+  }
+
+  test_binaryExpression_percent_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i % j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
+  }
+
+  test_binaryExpression_plus_left_check() async {
     await analyze('''
 int f(int i, int j) => i + j;
 ''');
@@ -295,7 +399,7 @@
         assertEdge(decoratedTypeAnnotation('int i').node, never, hard: true));
   }
 
-  test_binaryExpression_add_left_check_custom() async {
+  test_binaryExpression_plus_left_check_custom() async {
     await analyze('''
 class Int {
   Int operator+(Int other) => this;
@@ -307,7 +411,7 @@
         assertEdge(decoratedTypeAnnotation('Int i').node, never, hard: true));
   }
 
-  test_binaryExpression_add_result_custom() async {
+  test_binaryExpression_plus_result_custom() async {
     await analyze('''
 class Int {
   Int operator+(Int other) => this;
@@ -322,7 +426,7 @@
             hard: false));
   }
 
-  test_binaryExpression_add_result_not_null() async {
+  test_binaryExpression_plus_result_not_null() async {
     await analyze('''
 int f(int i, int j) => i + j;
 ''');
@@ -330,7 +434,7 @@
     assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
   }
 
-  test_binaryExpression_add_right_check() async {
+  test_binaryExpression_plus_right_check() async {
     await analyze('''
 int f(int i, int j) => i + j;
 ''');
@@ -339,7 +443,7 @@
         assertEdge(decoratedTypeAnnotation('int j').node, never, hard: true));
   }
 
-  test_binaryExpression_add_right_check_custom() async {
+  test_binaryExpression_plus_right_check_custom() async {
     await analyze('''
 class Int {
   Int operator+(Int other) => this;
@@ -354,12 +458,28 @@
             hard: true));
   }
 
-  test_binaryExpression_equal() async {
+  test_binaryExpression_slash_result_not_null() async {
     await analyze('''
-bool f(int i, int j) => i == j;
+double f(int i, int j) => i / j;
 ''');
 
-    assertNoUpstreamNullability(decoratedTypeAnnotation('bool f').node);
+    assertNoUpstreamNullability(decoratedTypeAnnotation('double f').node);
+  }
+
+  test_binaryExpression_star_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i * j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
+  }
+
+  test_binaryExpression_tildeSlash_result_not_null() async {
+    await analyze('''
+int f(int i, int j) => i ~/ j;
+''');
+
+    assertNoUpstreamNullability(decoratedTypeAnnotation('int f').node);
   }
 
   test_boolLiteral() async {