Don't crash on deserialized type inference.

tests/compiler/dart2js/serialization_helper.dart

 // Copyright (c) 2016, 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.
 
 library dart2js.serialization_helper;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:compiler/src/commandline_options.dart';
@@ skipping 193 matching lines @@
             _resolvedAstDeserializer.sourceFiles[script.resourceUri] =
                 newScript.file;
           });
         }).then((_) => library);
       }
     }
     return new Future<LibraryElement>.value(library);
   }
 
   @override
-  bool hasResolvedAst(Element element) {
+  bool hasResolvedAst(ExecutableElement element) {
     if (_resolvedAstDeserializer != null) {
       return _resolvedAstDeserializer.hasResolvedAst(element);
     }
     return false;
   }
 
   @override
-  ResolvedAst getResolvedAst(Element element) {
+  ResolvedAst getResolvedAst(ExecutableElement element) {
     if (_resolvedAstDeserializer != null) {
       return _resolvedAstDeserializer.getResolvedAst(element);
     }
     return null;
   }
 
   @override
   bool hasResolutionImpact(Element element) {
     if (element.isConstructor &&
             element.enclosingClass.isUnnamedMixinApplication) {
@@ skipping 60 matching lines @@
           backend.serialization.serializer).serialize();
     }
   }
 }
 
 class ResolvedAstDeserializerPlugin extends DeserializerPlugin {
   final ParsingContext parsingContext;
   final Backend backend;
   final Map<Uri, SourceFile> sourceFiles = <Uri, SourceFile>{};
 
-  Map<Element, ResolvedAst> _resolvedAstMap = <Element, ResolvedAst>{};
-  Map<Element, ObjectDecoder> _decoderMap = <Element, ObjectDecoder>{};
+  Map<ExecutableElement, ResolvedAst> _resolvedAstMap =
+      <ExecutableElement, ResolvedAst>{};
+  Map<MemberElement, ObjectDecoder> _decoderMap =
+      <MemberElement, ObjectDecoder>{};
   Map<Uri, Token> beginTokenMap = <Uri, Token>{};
 
   ResolvedAstDeserializerPlugin(this.parsingContext, this.backend);
 
-  bool hasResolvedAst(Element element) {
+  bool hasResolvedAst(ExecutableElement element) {
     return _resolvedAstMap.containsKey(element) ||
-        _decoderMap.containsKey(element);
+        _decoderMap.containsKey(element.memberContext);
   }
 
-  ResolvedAst getResolvedAst(Element element) {
+  ResolvedAst getResolvedAst(ExecutableElement element) {
     ResolvedAst resolvedAst = _resolvedAstMap[element];
     if (resolvedAst == null) {
-      ObjectDecoder decoder = _decoderMap[element];
+      ObjectDecoder decoder = _decoderMap[element.memberContext];
       if (decoder != null) {
-        resolvedAst = _resolvedAstMap[element] =
-            ResolvedAstDeserializer.deserialize(
-                element, decoder, parsingContext, findToken,
-                backend.serialization.deserializer);
+         ResolvedAstDeserializer.deserialize(
+             element.memberContext, decoder, parsingContext, findToken,
+             backend.serialization.deserializer,
+             _resolvedAstMap);
         _decoderMap.remove(element);
+        resolvedAst = _resolvedAstMap[element];
       }
     }
     return resolvedAst;
   }
 
   Token findToken(Uri uri, int offset) {
     Token beginToken = beginTokenMap.putIfAbsent(uri, () {
       SourceFile sourceFile = sourceFiles[uri];
       if (sourceFile == null) {
         throw 'No source file found for $uri in:\n '
               '${sourceFiles.keys.join('\n ')}';
       }
       return new Scanner(sourceFile).tokenize();
     });
     return ResolvedAstDeserializer.findTokenInStream(beginToken, offset);
   }
 
   @override
   void onElement(Element element, ObjectDecoder getDecoder(String tag)) {
     ObjectDecoder decoder = getDecoder(RESOLVED_AST_TAG);
     if (decoder != null) {
       _decoderMap[element] = decoder;
     }
   }
 }