diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 6c9fb86..6602462 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -2744,7 +2744,7 @@
 
     if (linkedNode != null) {
       var context = enclosingUnit.linkedContext;
-      return _constantInitializer = context.readInitializer(linkedNode);
+      return _constantInitializer = context.readInitializer(this, linkedNode);
     }
 
     if (_unlinkedConst != null) {
@@ -4893,9 +4893,9 @@
   /// [offset].
   FunctionElementImpl(String name, int offset) : super(name, offset);
 
-  FunctionElementImpl.forLinkedNode(CompilationUnitElementImpl enclosingUnit,
-      Reference reference, LinkedNode linkedNode)
-      : super.forLinkedNode(enclosingUnit, reference, linkedNode);
+  FunctionElementImpl.forLinkedNode(
+      ElementImpl enclosing, Reference reference, LinkedNode linkedNode)
+      : super.forLinkedNode(enclosing, reference, linkedNode);
 
   /// Initialize a newly created function element to have the given [name].
   FunctionElementImpl.forNode(Identifier name) : super.forNode(name);
@@ -4958,6 +4958,14 @@
   }
 
   @override
+  void set returnType(DartType returnType) {
+    if (linkedNode != null) {
+      enclosingUnit.linkedContext.setReturnType(linkedNode, returnType);
+    }
+    super.returnType = returnType;
+  }
+
+  @override
   SourceRange get visibleRange {
     if (serializedExecutable != null) {
       if (serializedExecutable.visibleLength == 0) {
@@ -9231,6 +9239,9 @@
   DartObject get constantValue => evaluationResult?.value;
 
   void set declaredType(DartType type) {
+    if (linkedNode != null) {
+      enclosingUnit.linkedContext.setVariableType(linkedNode, type);
+    }
     _declaredType = _checkElementOfType(type);
   }
 
diff --git a/pkg/analyzer/lib/src/summary/format.dart b/pkg/analyzer/lib/src/summary/format.dart
index ce7fd72..039749e 100644
--- a/pkg/analyzer/lib/src/summary/format.dart
+++ b/pkg/analyzer/lib/src/summary/format.dart
@@ -8978,7 +8978,8 @@
 
   @override
   LinkedNodeTypeBuilder get functionDeclaration_returnType2 {
-    assert(kind == idl.LinkedNodeKind.functionDeclaration);
+    assert(kind == idl.LinkedNodeKind.functionDeclaration ||
+        kind == idl.LinkedNodeKind.functionExpression);
     return _variantField_24;
   }
 
@@ -9036,7 +9037,8 @@
   }
 
   void set functionDeclaration_returnType2(LinkedNodeTypeBuilder value) {
-    assert(kind == idl.LinkedNodeKind.functionDeclaration);
+    assert(kind == idl.LinkedNodeKind.functionDeclaration ||
+        kind == idl.LinkedNodeKind.functionExpression);
     _variantField_24 = value;
   }
 
@@ -10701,10 +10703,12 @@
     LinkedNodeBuilder functionExpression_body,
     LinkedNodeBuilder functionExpression_formalParameters,
     LinkedNodeBuilder functionExpression_typeParameters,
+    LinkedNodeTypeBuilder functionDeclaration_returnType2,
   })  : _kind = idl.LinkedNodeKind.functionExpression,
         _variantField_6 = functionExpression_body,
         _variantField_7 = functionExpression_formalParameters,
-        _variantField_8 = functionExpression_typeParameters;
+        _variantField_8 = functionExpression_typeParameters,
+        _variantField_24 = functionDeclaration_returnType2;
 
   LinkedNodeBuilder.functionExpressionInvocation({
     LinkedNodeBuilder functionExpressionInvocation_function,
@@ -14558,7 +14562,8 @@
 
   @override
   idl.LinkedNodeType get functionDeclaration_returnType2 {
-    assert(kind == idl.LinkedNodeKind.functionDeclaration);
+    assert(kind == idl.LinkedNodeKind.functionDeclaration ||
+        kind == idl.LinkedNodeKind.functionExpression);
     _variantField_24 ??=
         const _LinkedNodeTypeReader().vTableGet(_bc, _bcOffset, 24, null);
     return _variantField_24;
@@ -16261,6 +16266,9 @@
       if (functionExpression_typeParameters != null)
         _result["functionExpression_typeParameters"] =
             functionExpression_typeParameters.toJson();
+      if (functionDeclaration_returnType2 != null)
+        _result["functionDeclaration_returnType2"] =
+            functionDeclaration_returnType2.toJson();
     }
     if (kind == idl.LinkedNodeKind.functionExpressionInvocation) {
       if (functionExpressionInvocation_function != null)
@@ -17613,6 +17621,7 @@
         "functionExpression_formalParameters":
             functionExpression_formalParameters,
         "functionExpression_typeParameters": functionExpression_typeParameters,
+        "functionDeclaration_returnType2": functionDeclaration_returnType2,
         "isSynthetic": isSynthetic,
         "kind": kind,
       };
diff --git a/pkg/analyzer/lib/src/summary/idl.dart b/pkg/analyzer/lib/src/summary/idl.dart
index e214f9c..e406e0c 100644
--- a/pkg/analyzer/lib/src/summary/idl.dart
+++ b/pkg/analyzer/lib/src/summary/idl.dart
@@ -1477,7 +1477,10 @@
   @VariantId(7, variant: LinkedNodeKind.functionDeclaration)
   LinkedNode get functionDeclaration_returnType;
 
-  @VariantId(24, variant: LinkedNodeKind.functionDeclaration)
+  @VariantId(24, variantList: [
+    LinkedNodeKind.functionDeclaration,
+    LinkedNodeKind.functionExpression,
+  ])
   LinkedNodeType get functionDeclaration_returnType2;
 
   @VariantId(6, variant: LinkedNodeKind.functionDeclarationStatement)
diff --git a/pkg/analyzer/lib/src/summary2/ast_binary_reader.dart b/pkg/analyzer/lib/src/summary2/ast_binary_reader.dart
index 93c7b51..e110d1d 100644
--- a/pkg/analyzer/lib/src/summary2/ast_binary_reader.dart
+++ b/pkg/analyzer/lib/src/summary2/ast_binary_reader.dart
@@ -13,11 +13,17 @@
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary2/linked_unit_context.dart';
+import 'package:analyzer/src/summary2/reference.dart';
 
 /// Deserializer of fully resolved ASTs from flat buffers.
 class AstBinaryReader {
   final LinkedUnitContext _unitContext;
 
+  ElementImpl _enclosingElement;
+  Reference _localRef;
+  int _localRefNextId;
+  List<ParameterElement> _localParameters;
+
   AstBinaryReader(this._unitContext);
 
   AstNode readNode(LinkedNode data) {
@@ -28,6 +34,27 @@
     return node;
   }
 
+  /// Run [f] that reads nodes with local declarations, making sure that
+  /// [_localRef] is ready for adding local references.
+  T withLocalScope<T>(ElementImpl enclosingElement, T f()) {
+    var isLocalContextOwner = _localRef == null;
+    try {
+      if (_localRef == null) {
+        _enclosingElement = enclosingElement;
+        _localRef = Reference.root().getChild('@local');
+        _localRefNextId = 0;
+      }
+      return f();
+    } finally {
+      if (isLocalContextOwner) {
+        _enclosingElement = null;
+        _localRef = null;
+        _localRefNextId = null;
+        _localParameters = null;
+      }
+    }
+  }
+
   ParameterKind _formalParameterKind(LinkedNodeFormalParameterKind kind) {
     if (kind == LinkedNodeFormalParameterKind.optionalNamed) {
       return ParameterKind.NAMED;
@@ -554,11 +581,37 @@
   }
 
   FunctionExpression _read_functionExpression(LinkedNode data) {
-    return astFactory.functionExpression(
+    var prevLocalParameters = _localParameters;
+    var thisLocalParameters = <ParameterElement>[];
+    _localParameters = thisLocalParameters;
+
+    var node = astFactory.functionExpression(
       _readNode(data.functionExpression_typeParameters),
       _readNode(data.functionExpression_formalParameters),
       _readNode(data.functionExpression_body),
     );
+    _localParameters = prevLocalParameters;
+
+    if (_localRef != null) {
+      var element = FunctionElementImpl.forLinkedNode(
+        _enclosingElement,
+        _localRef.getChild('${_localRefNextId++}'),
+        data,
+      );
+      element.parameters = thisLocalParameters;
+
+      var body = node.body;
+      if (body.isAsynchronous) {
+        element.asynchronous = true;
+      }
+      if (body.isGenerator) {
+        element.generator = true;
+      }
+
+      element.type = new FunctionTypeImpl(element);
+      (node as FunctionExpressionImpl).declaredElement = element;
+    }
+    return node;
   }
 
   FunctionExpressionInvocation _read_functionExpressionInvocation(
@@ -968,7 +1021,7 @@
   }
 
   SimpleFormalParameter _read_simpleFormalParameter(LinkedNode data) {
-    return astFactory.simpleFormalParameter2(
+    SimpleFormalParameterImpl node = astFactory.simpleFormalParameter2(
       identifier: _readNode(data.normalFormalParameter_identifier),
       type: _readNode(data.simpleFormalParameter_type),
       covariantKeyword: _getToken(data.normalFormalParameter_covariantKeyword),
@@ -976,6 +1029,20 @@
       metadata: _readNodeList(data.normalFormalParameter_metadata),
       keyword: _getToken(data.simpleFormalParameter_keyword),
     );
+
+    if (_localRef != null) {
+      var name = node.identifier.name;
+      var element = ParameterElementImpl.forLinkedNodeFactory(
+        _enclosingElement,
+        _localRef.getChild('${_localRefNextId++}').getChild(name),
+        data,
+      );
+      _localParameters.add(element);
+      node.identifier.staticElement = element;
+      node.declaredElement = element;
+    }
+
+    return node;
   }
 
   SimpleIdentifier _read_simpleIdentifier(LinkedNode data) {
diff --git a/pkg/analyzer/lib/src/summary2/link.dart b/pkg/analyzer/lib/src/summary2/link.dart
index d92ce20..0845951 100644
--- a/pkg/analyzer/lib/src/summary2/link.dart
+++ b/pkg/analyzer/lib/src/summary2/link.dart
@@ -76,6 +76,7 @@
       elementFactory,
       linkingBundle.references,
     );
+    bundleContext.linking = linkingBundleContext;
   }
 
   void link(List<LinkedNodeBundle> inputs,
@@ -132,7 +133,13 @@
   void _createTypeSystem() {
     var coreRef = rootReference.getChild('dart:core');
     var coreLib = elementFactory.elementOfReference(coreRef);
-    typeProvider = SummaryTypeProvider()..initializeCore(coreLib);
+
+    var asyncRef = rootReference.getChild('dart:async');
+    var asyncLib = elementFactory.elementOfReference(asyncRef);
+
+    typeProvider = SummaryTypeProvider()
+      ..initializeCore(coreLib)
+      ..initializeAsync(asyncLib);
     analysisContext.typeProvider = typeProvider;
 
     typeSystem = Dart2TypeSystem(typeProvider);
diff --git a/pkg/analyzer/lib/src/summary2/linked_bundle_context.dart b/pkg/analyzer/lib/src/summary2/linked_bundle_context.dart
index e0abe3a..630cb96 100644
--- a/pkg/analyzer/lib/src/summary2/linked_bundle_context.dart
+++ b/pkg/analyzer/lib/src/summary2/linked_bundle_context.dart
@@ -9,6 +9,7 @@
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary2/linked_element_factory.dart';
+import 'package:analyzer/src/summary2/linking_bundle_context.dart';
 import 'package:analyzer/src/summary2/reference.dart';
 
 /// The context of a linked bundle, with shared references.
@@ -17,6 +18,10 @@
   final LinkedNodeReferences referencesData;
   final List<Reference> _references;
 
+  /// If the bundle is being linked, the reference to the linking context.
+  /// Otherwise `null`, and we are not expected to access it.
+  LinkingBundleContext linking;
+
   LinkedBundleContext(this.elementFactory, this.referencesData)
       : _references = List<Reference>.filled(referencesData.name.length, null,
             growable: true);
diff --git a/pkg/analyzer/lib/src/summary2/linked_unit_context.dart b/pkg/analyzer/lib/src/summary2/linked_unit_context.dart
index a5fe43b..e6bf32c 100644
--- a/pkg/analyzer/lib/src/summary2/linked_unit_context.dart
+++ b/pkg/analyzer/lib/src/summary2/linked_unit_context.dart
@@ -4,6 +4,8 @@
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary2/ast_binary_reader.dart';
 import 'package:analyzer/src/summary2/linked_bundle_context.dart';
@@ -52,8 +54,9 @@
     if (kind == LinkedNodeKind.constructorDeclaration) {
       parameterList = node.constructorDeclaration_parameters;
     } else if (kind == LinkedNodeKind.functionDeclaration) {
-      parameterList = node.functionDeclaration_functionExpression
-          .functionExpression_formalParameters;
+      return getFormalParameters(node.functionDeclaration_functionExpression);
+    } else if (kind == LinkedNodeKind.functionExpression) {
+      parameterList = node.functionExpression_formalParameters;
     } else if (kind == LinkedNodeKind.functionTypeAlias) {
       parameterList = node.functionTypeAlias_formalParameters;
     } else if (kind == LinkedNodeKind.genericFunctionType) {
@@ -347,11 +350,16 @@
     }
   }
 
-  Expression readInitializer(LinkedNode linkedNode) {
-    if (linkedNode.kind == LinkedNodeKind.defaultFormalParameter) {
-      return readNode(linkedNode.defaultFormalParameter_defaultValue);
-    }
-    return readNode(linkedNode.variableDeclaration_initializer);
+  Expression readInitializer(ElementImpl enclosing, LinkedNode linkedNode) {
+    var reader = AstBinaryReader(this);
+    return reader.withLocalScope(enclosing, () {
+      if (linkedNode.kind == LinkedNodeKind.defaultFormalParameter) {
+        var data = linkedNode.defaultFormalParameter_defaultValue;
+        return reader.readNode(data);
+      }
+      var data = linkedNode.variableDeclaration_initializer;
+      return reader.readNode(data);
+    });
   }
 
   AstNode readNode(LinkedNode linkedNode) {
@@ -359,6 +367,16 @@
     return reader.readNode(linkedNode);
   }
 
+  void setReturnType(LinkedNodeBuilder node, DartType type) {
+    var typeData = bundleContext.linking.writeType(type);
+    node.functionDeclaration_returnType2 = typeData;
+  }
+
+  void setVariableType(LinkedNodeBuilder node, DartType type) {
+    var typeData = bundleContext.linking.writeType(type);
+    node.simpleFormalParameter_type2 = typeData;
+  }
+
   Iterable<LinkedNode> topLevelVariables(LinkedNode unit) sync* {
     for (var declaration in unit.compilationUnit_declarations) {
       if (declaration.kind == LinkedNodeKind.topLevelVariableDeclaration) {
@@ -375,8 +393,9 @@
     if (kind == LinkedNodeKind.constructorDeclaration) {
       return node.constructorDeclaration_body;
     } else if (kind == LinkedNodeKind.functionDeclaration) {
-      return node
-          .functionDeclaration_functionExpression.functionExpression_body;
+      return _getFunctionBody(node.functionDeclaration_functionExpression);
+    } else if (kind == LinkedNodeKind.functionExpression) {
+      return node.functionExpression_body;
     } else if (kind == LinkedNodeKind.methodDeclaration) {
       return node.methodDeclaration_body;
     } else {
diff --git a/pkg/analyzer/lib/src/summary2/top_level_inference.dart b/pkg/analyzer/lib/src/summary2/top_level_inference.dart
index def0f8d..8f16bbd 100644
--- a/pkg/analyzer/lib/src/summary2/top_level_inference.dart
+++ b/pkg/analyzer/lib/src/summary2/top_level_inference.dart
@@ -4,6 +4,7 @@
 
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
@@ -23,8 +24,13 @@
   final Linker linker;
   final Reference libraryRef;
   final UnitBuilder unit;
+  CompilationUnitElementImpl unitElement;
 
-  TopLevelInference(this.linker, this.libraryRef, this.unit);
+  TopLevelInference(this.linker, this.libraryRef, this.unit) {
+    unitElement = linker.elementFactory.elementOfReference(
+      libraryRef.getChild('@unit').getChild('${unit.uri}'),
+    );
+  }
 
   void infer() {
     _inferFieldsTemporary();
@@ -131,7 +137,7 @@
       return;
     }
 
-    var expression = unit.context.readInitializer(node);
+    var expression = unit.context.readInitializer(unitElement, node);
     astFactory.expressionFunctionBody(null, null, expression, null);
 
     // TODO(scheglov) can be shared for the whole library
diff --git a/pkg/analyzer/test/src/summary/resynthesize_ast2_test.dart b/pkg/analyzer/test/src/summary/resynthesize_ast2_test.dart
index 087ef97..43d2c22 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_ast2_test.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_ast2_test.dart
@@ -2,6 +2,7 @@
 // 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.
 
+import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ -33,6 +34,8 @@
   Future<LibraryElementImpl> checkLibrary(String text,
       {bool allowErrors = false, bool dumpSummaries = false}) async {
     var dartCoreSource = sourceFactory.forUri('dart:core');
+    var dartAsyncSource = sourceFactory.forUri('dart:async');
+
     var dartCoreCode = getFile(dartCoreSource.fullName).readAsStringSync();
     dartCoreCode = r'''
 library dart.core;
@@ -112,7 +115,18 @@
 }
 ''';
 
-    var dartCoreResult = _link(dartCoreSource, dartCoreCode);
+    var dartAsyncCode = r'''
+library dart.async;
+
+class Future<T> {}
+
+class FutureOr<T> {}
+''';
+
+    var dartCoreResult = _link({
+      dartCoreSource: dartCoreCode,
+      dartAsyncSource: dartAsyncCode,
+    });
 
     var source = addTestSource(text);
     var unit = parseText(text, experimentStatus: experimentStatus);
@@ -150,7 +164,10 @@
     elementFactory.addBundle(linkResult.bundle);
 
     var dartCore = elementFactory.libraryOfUri('dart:core');
-    var typeProvider = SummaryTypeProvider()..initializeCore(dartCore);
+    var dartAsync = elementFactory.libraryOfUri('dart:async');
+    var typeProvider = SummaryTypeProvider()
+      ..initializeCore(dartCore)
+      ..initializeAsync(dartAsync);
     analysisContext.typeProvider = typeProvider;
     analysisContext.typeSystem = Dart2TypeSystem(typeProvider);
 
@@ -984,24 +1001,6 @@
 
   @override
   @failingTest
-  test_futureOr() async {
-    await super.test_futureOr();
-  }
-
-  @override
-  @failingTest
-  test_futureOr_const() async {
-    await super.test_futureOr_const();
-  }
-
-  @override
-  @failingTest
-  test_futureOr_inferred() async {
-    await super.test_futureOr_inferred();
-  }
-
-  @override
-  @failingTest
   test_genericFunction_asFunctionTypedParameterReturnType() async {
     await super.test_genericFunction_asFunctionTypedParameterReturnType();
   }
@@ -1178,40 +1177,6 @@
 
   @override
   @failingTest
-  test_initializer_executable_with_return_type_from_closure() async {
-    await super.test_initializer_executable_with_return_type_from_closure();
-  }
-
-  @override
-  @failingTest
-  test_initializer_executable_with_return_type_from_closure_await_dynamic() async {
-    await super
-        .test_initializer_executable_with_return_type_from_closure_await_dynamic();
-  }
-
-  @override
-  @failingTest
-  test_initializer_executable_with_return_type_from_closure_await_future3_int() async {
-    await super
-        .test_initializer_executable_with_return_type_from_closure_await_future3_int();
-  }
-
-  @override
-  @failingTest
-  test_initializer_executable_with_return_type_from_closure_await_future_int() async {
-    await super
-        .test_initializer_executable_with_return_type_from_closure_await_future_int();
-  }
-
-  @override
-  @failingTest
-  test_initializer_executable_with_return_type_from_closure_await_future_noArg() async {
-    await super
-        .test_initializer_executable_with_return_type_from_closure_await_future_noArg();
-  }
-
-  @override
-  @failingTest
   test_initializer_executable_with_return_type_from_closure_field() async {
     await super
         .test_initializer_executable_with_return_type_from_closure_field();
@@ -1563,18 +1528,6 @@
 
   @override
   @failingTest
-  test_syntheticFunctionType_noArguments() async {
-    await super.test_syntheticFunctionType_noArguments();
-  }
-
-  @override
-  @failingTest
-  test_syntheticFunctionType_withArguments() async {
-    await super.test_syntheticFunctionType_withArguments();
-  }
-
-  @override
-  @failingTest
   test_type_arguments_implicit() async {
     await super.test_type_arguments_implicit();
   }
@@ -1605,18 +1558,6 @@
 
   @override
   @failingTest
-  test_type_inference_nested_function() async {
-    await super.test_type_inference_nested_function();
-  }
-
-  @override
-  @failingTest
-  test_type_inference_nested_function_with_parameter_types() async {
-    await super.test_type_inference_nested_function_with_parameter_types();
-  }
-
-  @override
-  @failingTest
   test_type_inference_of_closure_with_default_value() async {
     await super.test_type_inference_of_closure_with_default_value();
   }
@@ -1870,13 +1811,14 @@
     await super.test_variable_setterInPart_getterInPart();
   }
 
-  LinkResult _link(Source source, String code) {
-    var unit = parseText(code, experimentStatus: experimentStatus);
-
-    // TODO(scheglov) add other libraries
-    var libraryUnitMap = {
-      source: {source: unit},
-    };
+  LinkResult _link(Map<Source, String> codeMap) {
+    // TODO(scheglov) support for parts
+    var libraryUnitMap = <Source, Map<Source, CompilationUnit>>{};
+    for (var source in codeMap.keys) {
+      var code = codeMap[source];
+      var unit = parseText(code, experimentStatus: experimentStatus);
+      libraryUnitMap[source] = {source: unit};
+    }
 
     return link(
       AnalysisOptionsImpl(),