remove ClosureWrap option and related implementation

lib/src/info.dart

 // Copyright (c) 2015, 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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 library dev_compiler.src.info;
 
 import 'dart:mirrors';
 
@@ skipping 57 matching lines @@
 // The abstract type of coercions mapping one type to another.
 // This class also exposes static builder functions which
 // check for errors and reduce redundant coercions to the identity.
 abstract class Coercion {
   final DartType fromType;
   final DartType toType;
   Coercion(this.fromType, this.toType);
   static Coercion cast(DartType fromT, DartType toT) => new Cast(fromT, toT);
   static Coercion identity(DartType type) => new Identity(type);
   static Coercion error() => new CoercionError();
-  static Coercion wrapper(DartType fromType, DartType toType,
-      List<Coercion> normalParameters, List<Coercion> optionalParameters,
-      Map<String, Coercion> namedParameters, Coercion ret) {
-    {
-      // If any sub coercion is error, return error
-      bool isError(Coercion c) => c is CoercionError;
-      if (ret is CoercionError) return error();
-      if (namedParameters.values.any(isError)) return error();
-      if (normalParameters.any(isError)) return error();
-      if (optionalParameters.any(isError)) return error();
-    }
-    {
-      // If all sub coercions are the identity, return identity
-      bool folder(bool id, Coercion c) => id && (c is Identity);
-      bool id = (ret is CoercionError);
-      id = namedParameters.values.fold(id, folder);
-      id = normalParameters.fold(id, folder);
-      id = optionalParameters.fold(id, folder);
-      if (id) return identity(fromType);
-    }
-    return new Wrapper(fromType, toType, normalParameters, optionalParameters,
-        namedParameters, ret);
-  }
 }
 
 // Coercion which casts one type to another
 class Cast extends Coercion {
   Cast(DartType fromType, DartType toType) : super(fromType, toType);
 }
 
 // The identity coercion
 class Identity extends Coercion {
   Identity(DartType fromType) : super(fromType, fromType);
 }
 
-// A closure wrapper coercion.
-// The parameter coercions are the coercions which should
-// be applied to coerce the wrapper parameters to the
-// appropriate type for the wrapped closure.
-// The return coercion is appropriate to coerce the return
-// value of the wrapped function to the type expected by the
-// context.
-class Wrapper extends Coercion {
-  final Map<String, Coercion> namedParameters;
-  final List<Coercion> normalParameters;
-  final List<Coercion> optionalParameters;
-  final Coercion ret;
-  Wrapper(DartType fromType, DartType toType, this.normalParameters,
-      this.optionalParameters, this.namedParameters, this.ret)
-      : super(fromType, toType);
-}
-
 // The error coercion.  This coercion signals that a coercion
 // could not be generated.  The code generator should not see
 // these.
 class CoercionError extends Coercion {
   CoercionError() : super(null, null);
 }
 
 abstract class StaticInfo implements Message {
   /// AST Node this info is attached to.
   // TODO(jmesserly): this is somewhat redundant with SemanticNode.
@@ skipping 266 matching lines @@
   InferredTypeAllocation(TypeRules rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 }
 
 // An inferred type for a closure expression
 class InferredTypeClosure extends InferredTypeBase {
   InferredTypeClosure(TypeRules rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 }
 
-// TODO(vsm): Remove these.
-
-// A wrapped closure coerces the underlying type to the desired type.
-class ClosureWrapBase extends Conversion {
-  FunctionType _wrappedType;
-  Wrapper _wrapper;
-
-  ClosureWrapBase._internal(
-      TypeRules rules, Expression expression, this._wrapper, this._wrappedType)
-      : super(rules, expression) {
-    assert(baseType is FunctionType);
-    assert(!rules.isSubTypeOf(baseType, _wrappedType));
-  }
-
-  DartType _getConvertedType() => _wrappedType;
-
-  String get message => '$expression ($baseType) will need to be wrapped '
-      'with a closure of type $convertedType';
-
-  Level get level => Level.WARNING;
-
-  Wrapper get wrapper => _wrapper;
-
-  accept(AstVisitor visitor) {
-    if (visitor is ConversionVisitor) {
-      return visitor.visitClosureWrapBase(this);
-    } else {
-      return expression.accept(visitor);
-    }
-  }
-}
-
-// Standard closure wrapping.
-class ClosureWrap extends ClosureWrapBase {
-  ClosureWrap(TypeRules rules, Expression expression, Wrapper wrapper,
-      FunctionType wrappedType)
-      : super._internal(rules, expression, wrapper, wrappedType);
-
-  static ClosureWrapBase create(TypeRules rules, Expression expression,
-      Wrapper wrapper, FunctionType wrappedType) {
-    // Specialized wrappers:
-    if (expression is FunctionExpression) {
-      // The expression is a function literal / inline closure.
-      return new ClosureWrapLiteral(rules, expression, wrapper, wrappedType);
-    }
-    return new ClosureWrap(rules, expression, wrapper, wrappedType);
-  }
-}
-
-// "Wrapping" of an inline closure.  This could be optimized and / or we
-// could propagate the types into the literal.
-class ClosureWrapLiteral extends ClosureWrapBase {
-  ClosureWrapLiteral(TypeRules rules, Expression expression, Wrapper wrapper,
-      FunctionType wrappedType)
-      : super._internal(rules, expression, wrapper, wrappedType);
-}
-
 class DynamicInvoke extends Conversion {
   DynamicInvoke(TypeRules rules, Expression expression)
       : super(rules, expression);
 
   DartType _getConvertedType() => rules.provider.dynamicType;
 
   String get message => '$expression requires dynamic invoke';
   Level get level => Level.INFO;
 
   accept(AstVisitor visitor) {
@@ skipping 175 matching lines @@
 abstract class ConversionVisitor<R> implements AstVisitor<R> {
   /// This method must be implemented. It is typically supplied by the base
   /// GeneralizingAstVisitor<R>.
   R visitNode(AstNode node);
 
   /// The catch-all for any kind of conversion
   R visitConversion(Conversion node) => visitNode(node);
 
   // Methods for conversion subtypes:
   R visitDownCast(DownCast node) => visitConversion(node);
-  R visitClosureWrapBase(ClosureWrapBase node) => visitConversion(node);
-  R visitClosureWrap(ClosureWrap node) => visitClosureWrapBase(node);
   R visitDynamicInvoke(DynamicInvoke node) => visitConversion(node);
   R visitInferredTypeBase(InferredTypeBase node) => visitConversion(node);
 }
 
 /// Automatically infer list of types by scanning this library using mirrors.
 final List<Type> infoTypes = () {
   var allTypes = new Set();
   var baseTypes = new Set();
   var infoMirror = reflectClass(StaticInfo);
   var libMirror = infoMirror.owner as LibraryMirror;
@@ skipping 15 matching lines @@
     var isError = severity == analyzer.ErrorSeverity.WARNING;
     var level = isError ? Level.SEVERE : Level.WARNING;
     int begin = error.offset;
     int end = begin + error.length;
     return new AnalyzerError(error.message, level, begin, end);
   }
 
   const AnalyzerError(String message, Level level, int begin, int end)
       : super(message, level, begin, end);
 }