Handle null literal in compile_from_dill

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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.
 
 import 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
@@ skipping 346 matching lines @@
   }
 
   ResolutionInterfaceType getDartTypeOfMapLiteral(ir.MapLiteral literal) {
     ast.Node node = getNodeOrNull(literal);
     if (node != null) return elements.getType(node);
     assertNodeIsSynthetic(literal);
     return _compiler.commonElements
         .mapType(getDartType(literal.keyType), getDartType(literal.valueType));
   }
 
-  ResolutionDartType getFunctionReturnType(ir.FunctionNode node) {
-    if (node.returnType is ir.InvalidType) return const ResolutionDynamicType();
-    return getDartType(node.returnType);
-  }
-
   /// Computes the function type corresponding the signature of [node].
   ResolutionFunctionType getFunctionType(ir.FunctionNode node) {
-    ResolutionDartType returnType = getFunctionReturnType(node);
+    ResolutionDartType returnType = getDartType(node.returnType);
     List<ResolutionDartType> parameterTypes = <ResolutionDartType>[];
     List<ResolutionDartType> optionalParameterTypes = <ResolutionDartType>[];
     for (ir.VariableDeclaration variable in node.positionalParameters) {
       if (parameterTypes.length == node.requiredParameterCount) {
         optionalParameterTypes.add(getDartType(variable.type));
       } else {
         parameterTypes.add(getDartType(variable.type));
       }
     }
     List<String> namedParameters = <String>[];
@@ skipping 102 matching lines @@
     return const ResolutionVoidType();
   }
 
   @override
   ResolutionDartType visitDynamicType(ir.DynamicType node) {
     return const ResolutionDynamicType();
   }
 
   @override
   ResolutionDartType visitInvalidType(ir.InvalidType node) {
-    if (topLevel) {
-      throw new UnimplementedError(
-          "Outermost invalid types not currently supported");
-    }
-    // Nested invalid types are treated as `dynamic`.
+    // 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 ResolutionDynamicType();
   }
 }
 
 class KernelJumpTarget extends JumpTarget {
   static int index = 0;
 
   /// Pointer to the actual executable statements that a jump target refers to.
   /// If this jump target was not initially constructed with a LabeledStatement,
   /// this value is identical to originalStatement. This Node is actually of
@@ skipping 197 matching lines @@
   TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
     return TypeMaskFactory.inferredTypeForSelector(
         selector, mask, _globalInferenceResults);
   }
 
   TypeMask typeFromNativeBehavior(
       native.NativeBehavior nativeBehavior, ClosedWorld closedWorld) {
     return TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
   }
 }