@@ -41,6 +41,7 @@ class DecoratedType {
       this.namedParameters = const {},
       this.typeArguments = const []}) {
     assert(node != null);
+    assert(type is! FunctionType || returnType != null);
   }
 
   /// Creates a [DecoratedType] corresponding to the given [element], which is
 
@@ -10,6 +10,7 @@ import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/handle.dart';
 import 'package:analyzer/src/dart/element/inheritance_manager2.dart';
 import 'package:analyzer/src/dart/element/member.dart';
+import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:meta/meta.dart';
@@ -132,7 +133,8 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType> {
       } else {
         assert(baseElement.isSetter);
         decoratedBaseType = DecoratedType(baseElement.type, _graph.never,
-            positionalParameters: [decoratedElementType]);
+            positionalParameters: [decoratedElementType],
+            returnType: DecoratedType(VoidTypeImpl.instance, _graph.always));
       }
     } else {
       decoratedBaseType = _variables.decoratedElementType(baseElement);
@@ -323,8 +325,19 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType> {
     assert(_isSimple(thenType)); // TODO(paulberry)
     var elseType = node.elseExpression.accept(this);
     assert(_isSimple(elseType)); // TODO(paulberry)
+
+    DartType staticType = node.staticType;
+    DecoratedType returnType;
+    if (staticType is FunctionType) {
+      DartType functReturnType = staticType.returnType;
+      returnType = functReturnType.isDynamic || functReturnType.isVoid
+          // TODO(danrubel): handle LUB for constituent types
+          ? DecoratedType(functReturnType, _graph.always)
+          : _variables.decoratedElementType(functReturnType.element);
+    }
     var overallType = DecoratedType(
-        node.staticType, NullabilityNode.forLUB(thenType.node, elseType.node));
+        staticType, NullabilityNode.forLUB(thenType.node, elseType.node),
+        returnType: returnType);
     _variables.recordDecoratedExpressionType(node, overallType);
     return overallType;
   }
 
@@ -836,6 +836,25 @@ class C {
         decoratedTypeAnnotation('int i').node);
   }
 
+  test_function_assignment() async {
+    await analyze('''
+class C {
+  void f1(String message) {}
+  void f2(String message) {}
+}
+foo(C c, bool flag) {
+  Function(String message) out = flag ? c.f1 : c.f2;
+  out('hello');
+}
+bar() {
+  foo(C(), true);
+  foo(C(), false);
+}
+''');
+    var type = decoratedTypeAnnotation('Function(String message)');
+    expect(type.returnType, isNotNull);
+  }
+
   test_functionDeclaration_expression_body() async {
     await analyze('''
 int/*1*/ f(int/*2*/ i) => i/*3*/;
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ class DecoratedType {`
`41`	`41`	`this.namedParameters = const {},`
`42`	`42`	`this.typeArguments = const []}) {`
`43`	`43`	`assert(node != null);`
	`44`	`+ assert(type is! FunctionType \|\| returnType != null);`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`/// Creates a [DecoratedType] corresponding to the given [element], which is`