diff --git a/pkg/compiler/lib/src/ir/element_map.dart b/pkg/compiler/lib/src/ir/element_map.dart
index 16de410..250c391 100644
--- a/pkg/compiler/lib/src/ir/element_map.dart
+++ b/pkg/compiler/lib/src/ir/element_map.dart
@@ -53,6 +53,10 @@
   /// Returns the [CallStructure] corresponding to the [arguments].
   CallStructure getCallStructure(ir.Arguments arguments);
 
+  /// Returns the [TypeVariableEntity] corresponding to the type parameter
+  /// [node].
+  TypeVariableEntity getTypeVariable(ir.TypeParameter node);
+
   CommonElements get commonElements;
   DiagnosticReporter get reporter;
   InterfaceType getThisType(IndexedClass cls);
diff --git a/pkg/compiler/lib/src/ir/visitors.dart b/pkg/compiler/lib/src/ir/visitors.dart
index 5c0ab85..3e97494 100644
--- a/pkg/compiler/lib/src/ir/visitors.dart
+++ b/pkg/compiler/lib/src/ir/visitors.dart
@@ -507,3 +507,116 @@
     }
   }
 }
+
+/// Visitor that converts kernel dart types into [DartType].
+class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
+  final IrToElementMap elementMap;
+  final Map<ir.TypeParameter, DartType> currentFunctionTypeParameters =
+      <ir.TypeParameter, DartType>{};
+  bool topLevel = true;
+
+  DartTypeConverter(this.elementMap);
+
+  DartType convert(ir.DartType type) {
+    topLevel = true;
+    return type.accept(this);
+  }
+
+  /// Visit a inner type.
+  DartType visitType(ir.DartType type) {
+    topLevel = false;
+    return type.accept(this);
+  }
+
+  InterfaceType visitSupertype(ir.Supertype node) {
+    ClassEntity cls = elementMap.getClass(node.classNode);
+    return new InterfaceType(cls, visitTypes(node.typeArguments));
+  }
+
+  List<DartType> visitTypes(List<ir.DartType> types) {
+    topLevel = false;
+    return new List.generate(
+        types.length, (int index) => types[index].accept(this));
+  }
+
+  @override
+  DartType visitTypeParameterType(ir.TypeParameterType node) {
+    DartType typeParameter = currentFunctionTypeParameters[node.parameter];
+    if (typeParameter != null) {
+      return typeParameter;
+    }
+    if (node.parameter.parent is ir.Typedef) {
+      // Typedefs are only used in type literals so we never need their type
+      // variables.
+      return const DynamicType();
+    }
+    return new TypeVariableType(elementMap.getTypeVariable(node.parameter));
+  }
+
+  @override
+  DartType visitFunctionType(ir.FunctionType node) {
+    int index = 0;
+    List<FunctionTypeVariable> typeVariables;
+    for (ir.TypeParameter typeParameter in node.typeParameters) {
+      FunctionTypeVariable typeVariable = new FunctionTypeVariable(index);
+      currentFunctionTypeParameters[typeParameter] = typeVariable;
+      typeVariables ??= <FunctionTypeVariable>[];
+      typeVariables.add(typeVariable);
+      index++;
+    }
+    if (typeVariables != null) {
+      for (int index = 0; index < typeVariables.length; index++) {
+        typeVariables[index].bound =
+            node.typeParameters[index].bound.accept(this);
+      }
+    }
+
+    FunctionType type = new FunctionType(
+        visitType(node.returnType),
+        visitTypes(node.positionalParameters
+            .take(node.requiredParameterCount)
+            .toList()),
+        visitTypes(node.positionalParameters
+            .skip(node.requiredParameterCount)
+            .toList()),
+        node.namedParameters.map((n) => n.name).toList(),
+        node.namedParameters.map((n) => visitType(n.type)).toList(),
+        typeVariables ?? const <FunctionTypeVariable>[]);
+    for (ir.TypeParameter typeParameter in node.typeParameters) {
+      currentFunctionTypeParameters.remove(typeParameter);
+    }
+    return type;
+  }
+
+  @override
+  DartType visitInterfaceType(ir.InterfaceType node) {
+    ClassEntity cls = elementMap.getClass(node.classNode);
+    if (cls.name == 'FutureOr' &&
+        cls.library == elementMap.commonElements.asyncLibrary) {
+      return new FutureOrType(visitTypes(node.typeArguments).single);
+    }
+    return new InterfaceType(cls, visitTypes(node.typeArguments));
+  }
+
+  @override
+  DartType visitVoidType(ir.VoidType node) {
+    return const VoidType();
+  }
+
+  @override
+  DartType visitDynamicType(ir.DynamicType node) {
+    return const DynamicType();
+  }
+
+  @override
+  DartType visitInvalidType(ir.InvalidType node) {
+    // Root uses such a `o is Unresolved` and `o as Unresolved` must be special
+    // cased in the builder, nested invalid types are treated as `dynamic`.
+    return const DynamicType();
+  }
+
+  @override
+  DartType visitBottomType(ir.BottomType node) {
+    return elementMap.commonElements.nullType;
+  }
+}
diff --git a/pkg/compiler/lib/src/js_model/element_map_impl.dart b/pkg/compiler/lib/src/js_model/element_map_impl.dart
index 0cafcf5..ccce835 100644
--- a/pkg/compiler/lib/src/js_model/element_map_impl.dart
+++ b/pkg/compiler/lib/src/js_model/element_map_impl.dart
@@ -46,20 +46,28 @@
 }
 
 class JsKernelToElementMap extends KernelToElementMapBase
-    with
-        JsElementCreatorMixin,
-        // TODO(johnniwinther): Avoid mixing in [ElementCreatorMixin]. The
-        // codegen world should be a strict subset of the resolution world and
-        // creating elements for IR nodes should therefore not be needed.
-        // Currently some are created purely for testing (like
-        // `element == commonElements.foo`, where 'foo' might not be live).
-        // Others are created because we do a
-        // `elementEnvironment.forEachLibraryMember(...)` call on each emitted
-        // library.
-        ElementCreatorMixin
-    implements
-        KernelToWorldBuilder,
-        JsToElementMap {
+    with JsElementCreatorMixin
+    implements KernelToWorldBuilder, JsToElementMap {
+  Map<ir.Library, IndexedLibrary> libraryMap = <ir.Library, IndexedLibrary>{};
+  Map<ir.Class, IndexedClass> classMap = <ir.Class, IndexedClass>{};
+  Map<ir.Typedef, IndexedTypedef> typedefMap = <ir.Typedef, IndexedTypedef>{};
+
+  /// Map from [ir.TypeParameter] nodes to the corresponding
+  /// [TypeVariableEntity].
+  ///
+  /// Normally the type variables are [IndexedTypeVariable]s, but for type
+  /// parameters on local function (in the frontend) these are _not_ since
+  /// their type declaration is neither a class nor a member. In the backend,
+  /// these type parameters belong to the call-method and are therefore indexed.
+  Map<ir.TypeParameter, TypeVariableEntity> typeVariableMap =
+      <ir.TypeParameter, TypeVariableEntity>{};
+  Map<ir.Member, IndexedConstructor> constructorMap =
+      <ir.Member, IndexedConstructor>{};
+  Map<ir.Procedure, IndexedFunction> methodMap =
+      <ir.Procedure, IndexedFunction>{};
+  Map<ir.Field, IndexedField> fieldMap = <ir.Field, IndexedField>{};
+  Map<ir.TreeNode, Local> localFunctionMap = <ir.TreeNode, Local>{};
+
   /// Map from members to the call methods created for their nested closures.
   Map<MemberEntity, List<FunctionEntity>> _nestedClosureMap =
       <MemberEntity, List<FunctionEntity>>{};
@@ -166,11 +174,13 @@
       }
       IndexedTypeVariable newTypeVariable = createTypeVariable(
           newTypeDeclaration, oldTypeVariable.name, oldTypeVariable.index);
-      typeVariables.register<IndexedTypeVariable, TypeVariableData>(
-          newTypeVariable, oldTypeVariableData.copy());
+      typeVariableMap[oldTypeVariableData.node] =
+          typeVariables.register<IndexedTypeVariable, TypeVariableData>(
+              newTypeVariable, oldTypeVariableData.copy());
       assert(newTypeVariable.typeVariableIndex ==
           oldTypeVariable.typeVariableIndex);
     }
+    //typeVariableMap.keys.forEach((n) => print(n.parent));
     // TODO(johnniwinther): We should close the environment in the beginning of
     // this constructor but currently we need the [MemberEntity] to query if the
     // member is live, thus potentially creating the [MemberEntity] in the
@@ -179,11 +189,6 @@
   }
 
   @override
-  Entity getClosure(ir.FunctionDeclaration node) {
-    throw new UnsupportedError('JsKernelToElementMap.getClosure');
-  }
-
-  @override
   void forEachNestedClosure(
       MemberEntity member, void f(FunctionEntity closure)) {
     assert(checkFamily(member));
@@ -239,8 +244,6 @@
     return cls;
   }
 
-  // TODO(johnniwinther): Reinsert these when [ElementCreatorMixin] is no longer
-  // mixed in.
   @override
   FieldEntity getFieldInternal(ir.Field node) {
     FieldEntity field = fieldMap[node];
@@ -263,6 +266,40 @@
   }
 
   @override
+  TypeVariableEntity getTypeVariableInternal(ir.TypeParameter node) {
+    TypeVariableEntity typeVariable = typeVariableMap[node];
+    if (typeVariable == null) {
+      if (node.parent is ir.FunctionNode) {
+        ir.FunctionNode func = node.parent;
+        int index = func.typeParameters.indexOf(node);
+        if (func.parent is ir.Constructor) {
+          ir.Constructor constructor = func.parent;
+          ir.Class cls = constructor.enclosingClass;
+          typeVariableMap[node] =
+              typeVariable = getTypeVariableInternal(cls.typeParameters[index]);
+        } else if (func.parent is ir.Procedure) {
+          ir.Procedure procedure = func.parent;
+          if (procedure.kind == ir.ProcedureKind.Factory) {
+            ir.Class cls = procedure.enclosingClass;
+            typeVariableMap[node] = typeVariable =
+                getTypeVariableInternal(cls.typeParameters[index]);
+          }
+        }
+      }
+    }
+    assert(typeVariable != null,
+        "No type variable entity for $node on ${node.parent is ir.FunctionNode ? node.parent.parent : node.parent}");
+    return typeVariable;
+  }
+
+  @override
+  TypedefEntity getTypedefInternal(ir.Typedef node) {
+    TypedefEntity typedef = typedefMap[node];
+    assert(typedef != null, "No typedef entity for $node");
+    return typedef;
+  }
+
+  @override
   FunctionEntity getConstructorBody(ir.Constructor node) {
     ConstructorEntity constructor = getConstructor(node);
     return _getConstructorBody(node, constructor);
diff --git a/pkg/compiler/lib/src/kernel/element_map_impl.dart b/pkg/compiler/lib/src/kernel/element_map_impl.dart
index 72d76ae..4e66347 100644
--- a/pkg/compiler/lib/src/kernel/element_map_impl.dart
+++ b/pkg/compiler/lib/src/kernel/element_map_impl.dart
@@ -751,6 +751,20 @@
         argumentCount, namedArguments, arguments.types.length);
   }
 
+  ParameterStructure getParameterStructure(ir.FunctionNode node,
+      // TODO(johnniwinther): Remove this when type arguments are passed to
+      // constructors like calling a generic method.
+      {bool includeTypeParameters: true}) {
+    // TODO(johnniwinther): Cache the computed function type.
+    int requiredParameters = node.requiredParameterCount;
+    int positionalParameters = node.positionalParameters.length;
+    int typeParameters = node.typeParameters.length;
+    List<String> namedParameters =
+        node.namedParameters.map((p) => p.name).toList()..sort();
+    return new ParameterStructure(requiredParameters, positionalParameters,
+        namedParameters, includeTypeParameters ? typeParameters : 0);
+  }
+
   Selector getSelector(ir.Expression node) {
     // TODO(efortuna): This is screaming for a common interface between
     // PropertyGet and SuperPropertyGet (and same for *Get). Talk to kernel
@@ -1257,52 +1271,61 @@
   }
 
   FunctionEntity getMethodInternal(ir.Procedure node) {
-    return methodMap[node] ??= _getMethodCreate(node);
-  }
-
-  FunctionEntity _getMethodCreate(ir.Procedure node) {
-    assert(
-        !envIsClosed,
-        "Environment of $this is closed. Trying to create "
-        "function for $node.");
-    LibraryEntity library;
-    ClassEntity enclosingClass;
-    if (node.enclosingClass != null) {
-      enclosingClass = getClassInternal(node.enclosingClass);
-      library = enclosingClass.library;
-    } else {
-      library = getLibraryInternal(node.enclosingLibrary);
+    IndexedFunction function = methodMap[node];
+    if (function == null) {
+      assert(
+          !envIsClosed,
+          "Environment of $this is closed. Trying to create "
+          "function for $node.");
+      LibraryEntity library;
+      ClassEntity enclosingClass;
+      if (node.enclosingClass != null) {
+        enclosingClass = getClassInternal(node.enclosingClass);
+        library = enclosingClass.library;
+      } else {
+        library = getLibraryInternal(node.enclosingLibrary);
+      }
+      Name name = getName(node.name);
+      bool isStatic = node.isStatic;
+      bool isExternal = node.isExternal;
+      // TODO(johnniwinther): Remove `&& !node.isExternal` when #31233 is fixed.
+      bool isAbstract = node.isAbstract && !node.isExternal;
+      AsyncMarker asyncMarker = getAsyncMarker(node.function);
+      switch (node.kind) {
+        case ir.ProcedureKind.Factory:
+          throw new UnsupportedError("Cannot create method from factory.");
+        case ir.ProcedureKind.Getter:
+          function = createGetter(library, enclosingClass, name, asyncMarker,
+              isStatic: isStatic,
+              isExternal: isExternal,
+              isAbstract: isAbstract);
+          break;
+        case ir.ProcedureKind.Method:
+        case ir.ProcedureKind.Operator:
+          function = createMethod(library, enclosingClass, name,
+              getParameterStructure(node.function), asyncMarker,
+              isStatic: isStatic,
+              isExternal: isExternal,
+              isAbstract: isAbstract);
+          break;
+        case ir.ProcedureKind.Setter:
+          assert(asyncMarker == AsyncMarker.SYNC);
+          function = createSetter(library, enclosingClass, name.setter,
+              isStatic: isStatic,
+              isExternal: isExternal,
+              isAbstract: isAbstract);
+          break;
+      }
+      members.register<IndexedFunction, FunctionData>(
+          function,
+          new FunctionDataImpl(node, node.function,
+              new RegularMemberDefinition(function, node)));
+      methodMap[node] = function;
+      for (ir.TypeParameter typeParameter in node.function.typeParameters) {
+        getTypeVariable(typeParameter);
+      }
     }
-    Name name = getName(node.name);
-    bool isStatic = node.isStatic;
-    bool isExternal = node.isExternal;
-    // TODO(johnniwinther): Remove `&& !node.isExternal` when #31233 is fixed.
-    bool isAbstract = node.isAbstract && !node.isExternal;
-    AsyncMarker asyncMarker = getAsyncMarker(node.function);
-    IndexedFunction function;
-    switch (node.kind) {
-      case ir.ProcedureKind.Factory:
-        throw new UnsupportedError("Cannot create method from factory.");
-      case ir.ProcedureKind.Getter:
-        function = createGetter(library, enclosingClass, name, asyncMarker,
-            isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
-        break;
-      case ir.ProcedureKind.Method:
-      case ir.ProcedureKind.Operator:
-        function = createMethod(library, enclosingClass, name,
-            getParameterStructure(node.function), asyncMarker,
-            isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
-        break;
-      case ir.ProcedureKind.Setter:
-        assert(asyncMarker == AsyncMarker.SYNC);
-        function = createSetter(library, enclosingClass, name.setter,
-            isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
-        break;
-    }
-    return members.register<IndexedFunction, FunctionData>(
-        function,
-        new FunctionDataImpl(
-            node, node.function, new RegularMemberDefinition(function, node)));
+    return function;
   }
 
   FieldEntity getFieldInternal(ir.Field node) {
@@ -1332,20 +1355,6 @@
         new FieldDataImpl(node, new RegularMemberDefinition(field, node)));
   }
 
-  ParameterStructure getParameterStructure(ir.FunctionNode node,
-      // TODO(johnniwinther): Remove this when type arguments are passed to
-      // constructors like calling a generic method.
-      {bool includeTypeParameters: true}) {
-    // TODO(johnniwinther): Cache the computed function type.
-    int requiredParameters = node.requiredParameterCount;
-    int positionalParameters = node.positionalParameters.length;
-    int typeParameters = node.typeParameters.length;
-    List<String> namedParameters =
-        node.namedParameters.map((p) => p.name).toList()..sort();
-    return new ParameterStructure(requiredParameters, positionalParameters,
-        namedParameters, includeTypeParameters ? typeParameters : 0);
-  }
-
   IndexedLibrary createLibrary(String name, Uri canonicalUri);
 
   IndexedClass createClass(LibraryEntity library, String name,
@@ -2039,119 +2048,6 @@
   }
 }
 
-/// Visitor that converts kernel dart types into [DartType].
-class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
-  final KernelToElementMapBase elementMap;
-  final Map<ir.TypeParameter, DartType> currentFunctionTypeParameters =
-      <ir.TypeParameter, DartType>{};
-  bool topLevel = true;
-
-  DartTypeConverter(this.elementMap);
-
-  DartType convert(ir.DartType type) {
-    topLevel = true;
-    return type.accept(this);
-  }
-
-  /// Visit a inner type.
-  DartType visitType(ir.DartType type) {
-    topLevel = false;
-    return type.accept(this);
-  }
-
-  InterfaceType visitSupertype(ir.Supertype node) {
-    ClassEntity cls = elementMap.getClass(node.classNode);
-    return new InterfaceType(cls, visitTypes(node.typeArguments));
-  }
-
-  List<DartType> visitTypes(List<ir.DartType> types) {
-    topLevel = false;
-    return new List.generate(
-        types.length, (int index) => types[index].accept(this));
-  }
-
-  @override
-  DartType visitTypeParameterType(ir.TypeParameterType node) {
-    DartType typeParameter = currentFunctionTypeParameters[node.parameter];
-    if (typeParameter != null) {
-      return typeParameter;
-    }
-    if (node.parameter.parent is ir.Typedef) {
-      // Typedefs are only used in type literals so we never need their type
-      // variables.
-      return const DynamicType();
-    }
-    return new TypeVariableType(elementMap.getTypeVariable(node.parameter));
-  }
-
-  @override
-  DartType visitFunctionType(ir.FunctionType node) {
-    int index = 0;
-    List<FunctionTypeVariable> typeVariables;
-    for (ir.TypeParameter typeParameter in node.typeParameters) {
-      FunctionTypeVariable typeVariable = new FunctionTypeVariable(index);
-      currentFunctionTypeParameters[typeParameter] = typeVariable;
-      typeVariables ??= <FunctionTypeVariable>[];
-      typeVariables.add(typeVariable);
-      index++;
-    }
-    if (typeVariables != null) {
-      for (int index = 0; index < typeVariables.length; index++) {
-        typeVariables[index].bound =
-            node.typeParameters[index].bound.accept(this);
-      }
-    }
-
-    FunctionType type = new FunctionType(
-        visitType(node.returnType),
-        visitTypes(node.positionalParameters
-            .take(node.requiredParameterCount)
-            .toList()),
-        visitTypes(node.positionalParameters
-            .skip(node.requiredParameterCount)
-            .toList()),
-        node.namedParameters.map((n) => n.name).toList(),
-        node.namedParameters.map((n) => visitType(n.type)).toList(),
-        typeVariables ?? const <FunctionTypeVariable>[]);
-    for (ir.TypeParameter typeParameter in node.typeParameters) {
-      currentFunctionTypeParameters.remove(typeParameter);
-    }
-    return type;
-  }
-
-  @override
-  DartType visitInterfaceType(ir.InterfaceType node) {
-    ClassEntity cls = elementMap.getClass(node.classNode);
-    if (cls.name == 'FutureOr' &&
-        cls.library == elementMap.commonElements.asyncLibrary) {
-      return new FutureOrType(visitTypes(node.typeArguments).single);
-    }
-    return new InterfaceType(cls, visitTypes(node.typeArguments));
-  }
-
-  @override
-  DartType visitVoidType(ir.VoidType node) {
-    return const VoidType();
-  }
-
-  @override
-  DartType visitDynamicType(ir.DynamicType node) {
-    return const DynamicType();
-  }
-
-  @override
-  DartType visitInvalidType(ir.InvalidType node) {
-    // Root uses such a `o is Unresolved` and `o as Unresolved` must be special
-    // cased in the builder, nested invalid types are treated as `dynamic`.
-    return const DynamicType();
-  }
-
-  @override
-  DartType visitBottomType(ir.BottomType node) {
-    return elementMap.commonElements.nullType;
-  }
-}
-
 /// [native.BehaviorBuilder] for kernel based elements.
 class KernelBehaviorBuilder extends native.BehaviorBuilder {
   final ElementEnvironment elementEnvironment;
diff --git a/pkg/compiler/lib/src/ssa/kernel_impact.dart b/pkg/compiler/lib/src/ssa/kernel_impact.dart
index 75b41d1..a1d6c47 100644
--- a/pkg/compiler/lib/src/ssa/kernel_impact.dart
+++ b/pkg/compiler/lib/src/ssa/kernel_impact.dart
@@ -812,6 +812,13 @@
   void visitTypeLiteral(ir.TypeLiteral node) {
     impactBuilder.registerTypeUse(
         new TypeUse.typeLiteral(elementMap.getDartType(node.type)));
+    if (node.type is ir.FunctionType) {
+      ir.FunctionType functionType = node.type;
+      assert(functionType.typedef != null);
+      // TODO(johnniwinther): Can we avoid the typedef type altogether?
+      // We need to ensure that the typedef is live.
+      elementMap.getTypedefType(functionType.typedef);
+    }
   }
 
   @override