[Kernel] Remove code from the old type propagation.

pkg/kernel/lib/transformations/closure/converter.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 kernel.transformations.closure.converter;
 
 import '../../ast.dart'
     show
         Arguments,
         Block,
@@ skipping 700 matching lines @@
     CloneVisitor cloner = substitution.isEmpty
         ? this.cloner
         : new CloneWithoutBody(typeSubstitution: substitution);
     FunctionNode function = procedure.function;
     List<TypeParameter> typeParameters =
         function.typeParameters.map(cloner.clone).toList();
     List<VariableDeclaration> positionalParameters =
         function.positionalParameters.map(cloner.clone).toList();
     List<VariableDeclaration> namedParameters =
         function.namedParameters.map(cloner.clone).toList();
-    // TODO(ahe): Clone or copy inferredReturnValue?
-    InferredValue inferredReturnValue = null;
 
     List<DartType> types = typeParameters
         .map((TypeParameter parameter) => new TypeParameterType(parameter))
         .toList();
     List<Expression> positional = positionalParameters
         .map((VariableDeclaration parameter) => new VariableGet(parameter))
         .toList();
     List<NamedExpression> named =
         namedParameters.map((VariableDeclaration parameter) {
       return new NamedExpression(parameter.name, new VariableGet(parameter));
     }).toList();
 
     Arguments arguments = new Arguments(positional, types: types, named: named);
     InvocationExpression invocation = procedure.isInstanceMember
         ? new MethodInvocation(receiver, procedure.name, arguments, procedure)
         : new StaticInvocation(procedure, arguments);
     return new FunctionNode(new ReturnStatement(invocation),
         typeParameters: typeParameters,
         positionalParameters: positionalParameters,
         namedParameters: namedParameters,
         requiredParameterCount: function.requiredParameterCount,
-        returnType: substitute(function.returnType, cloner.typeSubstitution),
-        inferredReturnValue: inferredReturnValue);
+        returnType: substitute(function.returnType, cloner.typeSubstitution));
   }
 
   /// Creates copies of the type variables in [original] and returns a
   /// substitution that can be passed to [substitute] to substitute all uses of
   /// [original] with their copies.
   Map<TypeParameter, DartType> copyTypeVariables(
       Iterable<TypeParameter> original) {
     if (original.isEmpty) return const <TypeParameter, DartType>{};
     Map<TypeParameter, DartType> substitution = <TypeParameter, DartType>{};
     for (TypeParameter t in original) {
@@ skipping 79 matching lines @@
   // TODO(ahe): Remove this method when we don't generate closure classes
   // anymore.
   void addClosureClassNote(Class closureClass) {
     closureClass.addMember(new Field(new Name("note"),
         type: coreTypes.stringClass.rawType,
         initializer: new StringLiteral(
             "This is temporary. The VM doesn't need closure classes."),
         fileUri: currentFileUri));
   }
 }