dead code elimination in reify_coercions

lib/src/codegen/reify_coercions.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.
 
 library dev_compiler.src.codegen.reify_coercions;
 
 import 'package:analyzer/analyzer.dart' as analyzer;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
-import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:logging/logging.dart' as logger;
 
 import 'package:dev_compiler/devc.dart' show AbstractCompiler;
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart' show CompilerOptions;
-import 'package:dev_compiler/src/utils.dart' as utils;
 
 import 'ast_builder.dart';
 
 final _log = new logger.Logger('dev_compiler.reify_coercions');
 
 // TODO(leafp) Factor this out or use an existing library
 class Tuple2<T0, T1> {
   final T0 e0;
   final T1 e1;
   Tuple2(this.e0, this.e1);
 }
 
 typedef T Function1<S, T>(S _);
 
 class NewTypeIdDesc {
   /// If null, then this is not a library level identifier (i.e. it's
   /// a type parameter, or a special type like void, dynamic, etc)
   LibraryElement importedFrom;
   /// True => use/def in same library
   bool fromCurrent;
   /// True => not a source variable
   bool synthetic;
   NewTypeIdDesc({this.fromCurrent, this.importedFrom, this.synthetic});
 }
 
-class _LocatedWrapper {
-  final String loc;
-  final Wrapper wrapper;
-  _LocatedWrapper(this.wrapper, this.loc);
-}
-
-abstract class InstrumentedRuntime {
-  Expression wrap(Expression coercion, Expression e, Expression fromType,
-      Expression toType, Expression dartIs, String kind, String location);
-  Expression cast(Expression e, Expression fromType, Expression toType,
-      Expression dartIs, String kind, String location, bool ground);
-  Expression type(Expression witnessFunction);
-}
-
 class _Inference extends DownwardsInference {
   TypeManager _tm;
 
   _Inference(TypeRules rules, this._tm) : super(rules);
 
   @override
   void annotateCastFromDynamic(Expression e, DartType t) {
     var cast = Coercion.cast(e.staticType, t);
     var node = new DynamicCast(rules, e, cast);
     if (!NodeReplacer.replace(e, node)) {
@@ skipping 35 matching lines @@
   void annotateFunctionExpression(FunctionExpression e, DartType returnType) {
     // Implicitly changes e.staticType
     (e.element as ExecutableElementImpl).returnType = returnType;
   }
 }
 
 // This class implements a pass which modifies (in place) the ast replacing
 // abstract coercion nodes with their dart implementations.
 class CoercionReifier extends analyzer.GeneralizingAstVisitor<Object>
     with ConversionVisitor<Object> {
-  final AnalysisContext _context;
   final CoercionManager _cm;
   final TypeManager _tm;
   final VariableManager _vm;
   final LibraryUnit _library;
   bool _skipCoercions = false;
-  final TypeRules _rules;
   final _Inference _inferrer;
-  final InstrumentedRuntime _runtime;
   final CompilerOptions _options;
 
-  CompilationUnit _unit;
+  CoercionReifier._(this._cm, this._tm, this._vm, this._library, this._inferrer,
+      this._options);
 
-  CoercionReifier._(this._cm, this._tm, this._vm, this._library, this._rules,
-      this._inferrer, this._runtime, this._context, this._options);
-
-  factory CoercionReifier(LibraryUnit library, AbstractCompiler compiler,
-      [InstrumentedRuntime runtime]) {
+  factory CoercionReifier(LibraryUnit library, AbstractCompiler compiler) {
     var vm = new VariableManager();
-    var tm =
-        new TypeManager(library.library.element.enclosingElement, vm, runtime);
-    var rules = compiler.rules;
-    var cm = new CoercionManager(vm, tm, rules, runtime);
-    var inferrer = new _Inference(rules, tm);
-    var context = compiler.context;
+    var tm = new TypeManager(library.library.element.enclosingElement, vm);
+    var cm = new CoercionManager(vm, tm);
+    var inferrer = new _Inference(compiler.rules, tm);
     var options = compiler.options;
-    return new CoercionReifier._(
-        cm, tm, vm, library, rules, inferrer, runtime, context, options);
+    return new CoercionReifier._(cm, tm, vm, library, inferrer, options);
   }
 
   // This should be the entry point for this class.  Entering via the
   // visit functions directly may not do the right thing with respect
   // to discharging the collected definitions.
   // Returns the set of new type identifiers added by the reifier
   Map<Identifier, NewTypeIdDesc> reify() {
     _library.partsThenLibrary.forEach(generateUnit);
     return _tm.addedTypes;
   }
 
   void generateUnit(CompilationUnit unit) {
-    _unit = unit;
     visitCompilationUnit(unit);
-    _unit = null;
   }
 
   ///////////////// Private //////////////////////////////////
 
-  String _locationInfo(Expression e) {
-    if (_unit != null) {
-      final begin = e is AnnotatedNode
-          ? (e as AnnotatedNode).firstTokenAfterCommentAndMetadata.offset
-          : e.offset;
-      if (begin != 0 && e.end > begin) {
-        var span = utils.createSpan(_context, _unit, begin, e.end);
-        var s = span.message("Cast");
-        return s.substring(0, s.indexOf("Cast"));
-      }
-    }
-    return null;
-  }
-
-  static String _conversionKind(Conversion node) {
-    if (node is ClosureWrapLiteral) return "WrapLiteral";
-    if (node is ClosureWrap) return "Wrap";
-    if (node is DynamicCast) return "DynamicCast";
-    if (node is AssignmentCast) return "AssignmentCast";
-    if (node is UninferredClosure) return "InferableClosure";
-    if (node is DownCastComposite) return "CompositeCast";
-    if (node is DownCastImplicit) return "ImplicitCast";
-    assert(false);
-    return "";
-  }
-
-  @override
-  Object visitAsExpression(AsExpression e) {
-    if (_runtime == null) return super.visitAsExpression(e);
-    var cast = Coercion.cast(_rules.getStaticType(e.expression), e.type.type);
-    var loc = _locationInfo(e);
-    Expression castNode =
-        _cm.coerceExpression(e.expression, cast, "CastUser", loc);
-    if (!NodeReplacer.replace(e, castNode)) {
-      _log.severe("Failed to replace node for DownCast");
-    }
-    castNode.accept(this);
-    return null;
-  }
-
   @override
   Object visitInferredTypeBase(InferredTypeBase node) {
     var expr = node.node;
     var b = _inferrer.inferExpression(expr, node.type, <String>[]);
     assert(b);
     if (!NodeReplacer.replace(node, expr)) {
       _log.severe("Failed to replace node for InferredType");
     }
     expr.accept(this);
     return null;
   }
 
   @override
   Object visitDownCast(DownCast node) {
     if (_skipCoercions && !_options.allowConstCasts) {
       _log.severe("Skipping runtime downcast in constant context");
       return null;
     }
-    String kind = _conversionKind(node);
-    var loc = _locationInfo(node);
-    Expression castNode = _cm.coerceExpression(node.node, node.cast, kind, loc);
+    Expression castNode = _cm.coerceExpression(node.node, node.cast);
     if (!NodeReplacer.replace(node, castNode)) {
       _log.severe("Failed to replace node for DownCast");
     }
     castNode.accept(this);
     return null;
   }
 
   // TODO(leafp): Bind the coercions at the top level
   @override
   Object visitClosureWrapBase(ClosureWrapBase node) {
     if (_skipCoercions && !_options.allowConstCasts) {
       _log.severe("Skipping coercion wrap in constant context");
       return null;
     }
-    String kind = _conversionKind(node);
-    var loc = _locationInfo(node);
-    Expression newE = _cm.coerceExpression(node.node, node.wrapper, kind, loc);
+    Expression newE = _cm.coerceExpression(node.node, node.wrapper);
     if (!NodeReplacer.replace(node, newE)) {
       _log.severe("Failed to replace node for Closure Wrap");
     }
     newE.accept(this);
     return null;
   }
 
   @override
   Object visitNode(AstNode n) {
     var o = _skipCoercions;
@@ skipping 59 matching lines @@
 // class level avoids having to close over type variables, which is not
 // easily done given the lack of generic functions).  Generating the coercions
 // inline is possible as well, but is quite a bit messier and harder to read
 // since in general we need to bind the coerced expression to a lambda
 // bound variable, both in order to deal with side-effects and to be
 // able to properly record the return type of the wrapper function.
 class CoercionManager {
   VariableManager _vm;
   TypeManager _tm;
   bool _hoistWrappers = false;
-  TypeRules _rules;
-  InstrumentedRuntime _runtime;
 
   // A map containing all of the wrappers collected but not yet discharged
-  final Map<Identifier, _LocatedWrapper> _topWrappers =
-      <Identifier, _LocatedWrapper>{};
-  final Map<Identifier, _LocatedWrapper> _classWrappers =
-      <Identifier, _LocatedWrapper>{};
-  Map<Identifier, _LocatedWrapper> _wrappers;
+  final Map<Identifier, Wrapper> _topWrappers = <Identifier, Wrapper>{};
+  final Map<Identifier, Wrapper> _classWrappers = <Identifier, Wrapper>{};
+  Map<Identifier, Wrapper> _wrappers;
 
-  CoercionManager(this._vm, this._tm, this._rules, [this._runtime]) {
+  CoercionManager(this._vm, this._tm) {
     _wrappers = _topWrappers;
   }
 
   // Call on entry to and exit from a compilation unit in order to properly
   // discharge the accumulated wrappers.
   void enterCompilationUnit(CompilationUnit unit) {
     _tm.enterCompilationUnit(unit);
     _wrappers = _topWrappers;
   }
   void exitCompilationUnit(CompilationUnit unit) {
     for (Identifier i in _wrappers.keys) {
-      FunctionDeclaration f =
-          _buildCoercion(i, _wrappers[i].wrapper, _wrappers[i].loc, true);
+      FunctionDeclaration f = _buildCoercion(i, _wrappers[i], true);
       unit.declarations.add(f);
     }
     _wrappers.clear();
     _wrappers = _topWrappers;
     _tm.exitCompilationUnit(unit);
   }
 
   // Call on entry to and exit from a class in order to properly
   // discharge the accumulated wrappers.
   void enterClass() {
     _wrappers = _classWrappers;
   }
   void exitClass(ClassDeclaration cl) {
     for (Identifier i in _wrappers.keys) {
-      ClassMember f =
-          _buildCoercion(i, _wrappers[i].wrapper, _wrappers[i].loc, false);
+      ClassMember f = _buildCoercion(i, _wrappers[i], false);
       cl.members.add(f);
     }
     _wrappers.clear();
     _wrappers = _topWrappers;
   }
 
   // The main entry point.  Coerce e using c, returning a new expression,
   // possibly recording additional coercions functions and typedefs to
   // be discharged at a higher level.
-  Expression coerceExpression(
-      Expression e, Coercion c, String kind, String loc) {
-    return _coerceExpression(e, c, kind, loc);
-  }
-
-  ///////////////// Private //////////////////////////////////
-  Tuple2<Identifier, Function1<Expression, Expression>> _bindExpression(
-      String hint, Expression e1) {
-    if (e1 is Identifier) {
-      return new Tuple2(e1, (e2) => e2);
-    }
-    var id = _vm.freshIdentifier(hint);
-    var fp = AstBuilder.simpleFormal(id, null);
-    Expression f(Expression e2) =>
-        AstBuilder.parenthesize(AstBuilder.letExpression(fp, e1, e2));
-    return new Tuple2(id, f);
-  }
-
-  Expression _wrapExpression(Expression e, Wrapper w, String k, String loc) {
-    var q = _addWrapper(w, loc);
-    if (_runtime == null) {
-      var app = AstBuilder.application(q, <Expression>[e]);
-      app.staticType = w.toType;
-      return app;
-    }
-    var ttName = _tm.typeNameFromDartType(w.toType);
-    var tt = _tm.typeExpression(ttName);
-    var ft = _tm.typeExpressionFromDartType(w.fromType);
-    if (w.fromType.element.library != null &&
-        utils.isDartPrivateLibrary(w.fromType.element.library)) {
-      ft = AstBuilder.nullLiteral();
-    }
-    var tup = _bindExpression("x", e);
-    var id = tup.e0;
-    var binder = tup.e1;
-    var dartIs = AstBuilder.isExpression(AstBuilder.parenthesize(id), ttName);
-    var oper = _runtime.wrap(q, id, ft, tt, dartIs, k, loc);
-    return binder(oper);
-  }
-
-  Expression _castExpression(Expression e, Cast c, String k, String loc) {
-    var ttName = _tm.typeNameFromDartType(c.toType);
-    if (_runtime == null) {
-      var cast = AstBuilder.asExpression(e, ttName);
-      cast.staticType = c.toType;
-      return cast;
-    }
-    var tt = _tm.typeExpression(ttName);
-    var ft = _tm.typeExpressionFromDartType(c.fromType);
-    if (c.fromType.element == null) {
-      // Replace bottom with Null type.
-      var ftType = _rules.provider.nullType;
-      ft = _tm.typeExpressionFromDartType(ftType);
-    } else if (c.fromType.element.library != null &&
-        utils.isDartPrivateLibrary(c.fromType.element.library)) {
-      ft = AstBuilder.nullLiteral();
-    }
-    var tup = _bindExpression("x", e);
-    var id = tup.e0;
-    var binder = tup.e1;
-    var dartIs = AstBuilder.isExpression(AstBuilder.parenthesize(id), ttName);
-    var ground = _rules.isGroundType(c.toType);
-    var oper = _runtime.cast(id, ft, tt, dartIs, k, loc, ground);
-    return binder(oper);
-  }
-
-  Expression _coerceExpression(
-      Expression e, Coercion c, String kind, String loc) {
+  Expression coerceExpression(Expression e, Coercion c) {
     assert(c != null);
     assert(c is! CoercionError);
     if (e is NamedExpression) {
-      Expression inner = _coerceExpression(e.expression, c, kind, loc);
+      Expression inner = coerceExpression(e.expression, c);
       return new NamedExpression(e.name, inner);
     }
-    if (c is Cast) return _castExpression(e, c, kind, loc);
-    if (c is Wrapper) return _wrapExpression(e, c, kind, loc);
+    if (c is Cast) return _castExpression(e, c);
+    if (c is Wrapper) return _wrapExpression(e, c);
     assert(c is Identity);
     return e;
   }
 
-  Expression _addWrapper(Wrapper w, String loc) {
+  ///////////////// Private //////////////////////////////////
+
+  Expression _wrapExpression(Expression e, Wrapper w) {
+    var q = _addWrapper(w);
+    var app = AstBuilder.application(q, <Expression>[e]);
+    app.staticType = w.toType;
+    return app;
+  }
+
+  Expression _castExpression(Expression e, Cast c) {
+    var ttName = _tm.typeNameFromDartType(c.toType);
+    var cast = AstBuilder.asExpression(e, ttName);
+    cast.staticType = c.toType;
+    return cast;
+  }
+
+  Expression _addWrapper(Wrapper w) {
     if (_hoistWrappers) {
       var q = _vm.freshIdentifier("q");
-      _wrappers[q] = new _LocatedWrapper(w, loc);
+      _wrappers[q] = w;
       return q;
     } else {
-      return _buildCoercionExpression(w, loc);
+      return _buildCoercionExpression(w);
     }
   }
 
   // Choose a canonical name for the ith coercion parameter
   // with name "name".
   Identifier _coercionParameter(String name, int index) {
     String s = name + index.toString();
     return AstBuilder.identifierFromString(s);
   }
 
@@ skipping 17 matching lines @@
     for (String k in namedParameters.keys) {
       // TODO(leafp): These could collide with the generated names.
       Identifier z = AstBuilder.identifierFromString(k);
       // We use the toType to avoid changing the reified type
       FormalParameter fp = _tm.typedFormal(z, namedParameters[k].toType);
       params.add(AstBuilder.namedFormal(fp));
     }
     return params;
   }
 
-  List<Expression> _wrapperCoercedArguments(Wrapper wrapper, String loc) {
+  List<Expression> _wrapperCoercedArguments(Wrapper wrapper) {
     var namedParameters = wrapper.namedParameters;
     var normalParameters = wrapper.normalParameters;
     var optionalParameters = wrapper.optionalParameters;
     var args = new List<Expression>();
     for (int i = 0; i < normalParameters.length; i++) {
       Identifier x = _coercionParameter("x", i);
-      Expression e =
-          _coerceExpression(x, normalParameters[i], "CastParam", loc);
+      Expression e = coerceExpression(x, normalParameters[i]);
       args.add(e);
     }
     for (int i = 0; i < optionalParameters.length; i++) {
       Identifier y = _coercionParameter("y", i);
-      Expression e =
-          _coerceExpression(y, optionalParameters[i], "CastParam", loc);
+      Expression e = coerceExpression(y, optionalParameters[i]);
       args.add(e);
     }
     for (String k in namedParameters.keys) {
       // TODO(leafp): These could collide with the generated names.
       Identifier z = AstBuilder.identifierFromString(k);
-      Expression e = _coerceExpression(z, namedParameters[k], "CastParam", loc);
+      Expression e = coerceExpression(z, namedParameters[k]);
       args.add(AstBuilder.namedParameter(k, e));
     }
     return args;
   }
 
   // Given an identifier c, a value f and a coercion q : T0 -> T1 => S0 -> S1
   // wrap f using q and bind it to variable c
   // T1 c(T0 x) => (f(x as T0) as S1)
   // Note that we use the "fromType" to decorate the wrapper
   // rather than the "toType" to avoid changing the reified type
   // TODO(leafp): If we wrap non-function literals, we can still
   // end up changing the runtime reified type, since we build a function
   // literal based on the static type.
   FunctionDeclarationStatement _wrapperMkInner(
-      Identifier c, Expression f, Wrapper wrapper, String loc) {
+      Identifier c, Expression f, Wrapper wrapper) {
     List<FormalParameter> params = _wrapperFormalParameters(wrapper);
-    List<Expression> args = _wrapperCoercedArguments(wrapper, loc);
+    List<Expression> args = _wrapperCoercedArguments(wrapper);
     Expression app = AstBuilder.application(f, args);
-    Expression body = _coerceExpression(app, wrapper.ret, "CastResult", loc);
+    Expression body = coerceExpression(app, wrapper.ret);
     FunctionExpression ce = AstBuilder.expressionFunction(params, body, true);
     TypeName rt =
         _tm.typeNameFromDartType((wrapper.fromType as FunctionType).returnType);
     Statement cDec = AstBuilder.functionDeclarationStatement(rt, c, ce);
     return cDec;
   }
 
   Tuple2<List<FormalParameter>, List<Statement>> _buildCoercionBody(
-      Wrapper wrapper, String loc) {
+      Wrapper wrapper) {
     var f = AstBuilder.identifierFromString("f");
     var c = AstBuilder.identifierFromString("c");
-    var cDec = _wrapperMkInner(c, f, wrapper, loc);
+    var cDec = _wrapperMkInner(c, f, wrapper);
     var comp = AstBuilder.binaryExpression(f, "==", AstBuilder.nullLiteral());
     var n = AstBuilder.nullLiteral();
     var cond = AstBuilder.conditionalExpression(comp, n, c);
     var stmts = <Statement>[cDec, AstBuilder.returnExpression(cond)];
     var fp = _tm.typedFormal(f, wrapper.fromType);
     var params = <FormalParameter>[fp];
     return new Tuple2<List<FormalParameter>, List<Statement>>(params, stmts);
   }
 
-  Expression _buildCoercionExpression(Wrapper wrapper, String loc) {
-    var tup = _buildCoercionBody(wrapper, loc);
+  Expression _buildCoercionExpression(Wrapper wrapper) {
+    var tup = _buildCoercionBody(wrapper);
     return AstBuilder.blockFunction(tup.e0, tup.e1);
   }
 
   // Given a name g and coercion q : T0 -> T1 => S0 -> S1
   // Bind g to a function or static method which maps
   // T0 -> T1 functions to S0 -> S1 functions.
   // T0 -> T1 g(S1 f(S0)) {
   //   T1 c(T0 x) => (f(x as T0) as S1);
   //   return (f == null) ? null : c;
   // }
-  Declaration _buildCoercion(
-      Identifier q, Wrapper wrapper, String loc, bool top) {
-    var tup = _buildCoercionBody(wrapper, loc);
+  Declaration _buildCoercion(Identifier q, Wrapper wrapper, bool top) {
+    var tup = _buildCoercionBody(wrapper);
     var params = tup.e0;
     var stmts = tup.e1;
     TypeName rt = _tm.typeNameFromDartType(wrapper.toType);
     if (top) {
       return AstBuilder.blockFunctionDeclaration(rt, q, params, stmts);
     } else {
       return AstBuilder.blockMethodDeclaration(rt, q, params, stmts);
     }
   }
 }
 
 // A class for managing the interaction between the DartType hierarchy
 // and the AST type representation.  It provides utilities to translate
 // a DartType to AST.  In order to do so, it maintains a map of typedefs
 // naming otherwise un-named types.  These must be discharged at the top
 // level of the compilation unit in order to produce well-formed dart code.
 // Note that in order to hoist the typedefs out of parameterized classes
 // we must close over any type variables.
 class TypeManager {
   final VariableManager _vm;
   final LibraryElement _currentLibrary;
   final Map<Identifier, NewTypeIdDesc> addedTypes = {};
-  final InstrumentedRuntime _runtime;
   CompilationUnitElement _currentUnit;
 
   /// A map containing new function typedefs to be introduced at the top level
   /// This uses LinkedHashMap to emit code in a consistent order.
   final Map<FunctionType, FunctionTypeAlias> _typedefs = {};
 
-  TypeManager(this._currentLibrary, this._vm, [this._runtime]);
+  TypeManager(this._currentLibrary, this._vm);
 
   void enterCompilationUnit(CompilationUnit unit) {
     _currentUnit = unit.element;
   }
 
   void exitCompilationUnit(CompilationUnit unit) {
     unit.declarations.addAll(_typedefs.values);
     _typedefs.clear();
   }
 
   TypeName typeNameFromDartType(DartType dType) {
     return _typeNameFromDartType(dType);
   }
 
   NormalFormalParameter typedFormal(Identifier v, DartType type) {
     return _typedFormal(v, type);
   }
 
-  Expression typeExpressionFromDartType(DartType t) =>
-      typeExpression(typeNameFromDartType(t));
-
-  Expression typeExpression(TypeName t) => _typeExpression(t);
-
   ///////////////// Private //////////////////////////////////
   List<TypeParameterType> _freeTypeVariables(DartType type) {
     var s = new Set<TypeParameterType>();
 
     void _ft(DartType type) {
       void _ftMap(Map<String, DartType> m) {
         if (m == null) return;
         for (var k in m.keys) _ft(m[k]);
       }
       void _ftList(List<DartType> l) {
@@ skipping 223 matching lines @@
     }
     var t = _mkNewTypeName(dType, id, args);
     return t;
   }
 
   TypeName _mkNewTypeName(DartType type, Identifier id, List<TypeName> args) {
     var t = AstBuilder.typeName(id, args);
     t.type = type;
     return t;
   }
-
-  Expression _typeExpression(TypeName t) {
-    assert(_runtime != null);
-    if (t.typeArguments != null && t.typeArguments.length > 0) {
-      var w = AstBuilder.identifierFromString("_");
-      var fp = AstBuilder.simpleFormal(w, t);
-      var f = AstBuilder.blockFunction(<FormalParameter>[fp], <Statement>[]);
-      return _runtime.type(f);
-    }
-    return t.name;
-  }
 }