Reifier hookup

lib/src/codegen/js_codegen.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.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
 import 'package:path/path.dart' as path;
 
 import 'package:dev_compiler/src/codegen/ast_builder.dart' show AstBuilder;
+import 'package:dev_compiler/src/codegen/reify_coercions.dart'
+    show CoercionReifier;
 
 // TODO(jmesserly): import from its own package
 import 'package:dev_compiler/src/js/js_ast.dart' as JS;
 import 'package:dev_compiler/src/js/js_ast.dart' show js;
 
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/utils.dart';
 
@@ skipping 15 matching lines @@
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final LibraryInfo libraryInfo;
   final TypeRules rules;
 
   /// The global extension method table.
   final HashMap<String, List<InterfaceType>> _extensionMethods;
 
+  final CompilerOptions options;
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   ClassDeclaration currentClass;
   ConstantEvaluator _constEvaluator;
 
   final _exports = new Set<String>();
   final _lazyFields = <VariableDeclaration>[];
@@ skipping 14 matching lines @@
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
   /// [ClassTypeAlias].
   final _pendingClasses = new HashMap<Element, CompilationUnitMember>();
 
   /// Memoized results of [_lazyClass].
   final _lazyClassMemo = new HashMap<Element, bool>();
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
 
-  JSCodegenVisitor(this.libraryInfo, this.rules, this._extensionMethods);
+  JSCodegenVisitor(
+      this.libraryInfo, this.rules, this.options, this._extensionMethods);
 
   LibraryElement get currentLibrary => libraryInfo.library;
   TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
     String jsDefaultValue = null;
+
+    // Modify the AST to make coercions explicit.
+    new CoercionReifier(library, rules, options).reify();
+
     var unit = library.library;
     if (unit.directives.isNotEmpty) {
       var libraryDir = unit.directives.first;
       if (libraryDir is LibraryDirective) {
         var jsName = getAnnotationValue(libraryDir, _isJsNameAnnotation);
         jsDefaultValue = getConstantField(jsName, 'name', types.stringType);
       }
     }
     if (jsDefaultValue == null) jsDefaultValue = '{}';
 
@@ skipping 87 matching lines @@
 
     assert(_pendingPrivateNames.isEmpty);
     return _statement(body);
   }
 
   bool isPublic(String name) => !name.startsWith('_');
 
   /// Conversions that we don't handle end up here.
   @override
   visitConversion(Conversion node) {
-    var from = node.baseType;
-    var to = node.convertedType;
+    throw 'Unlowered conversion ${node.runtimeType}: $node';
+  }
+
+  @override
+  visitAsExpression(AsExpression node) {
+    var from = getStaticType(node.expression);
+    var to = node.type.type;
 
     // All Dart number types map to a JS double.
     if (rules.isNumType(from) &&
         (rules.isIntType(to) || rules.isDoubleType(to))) {
       // TODO(jmesserly): a lot of these checks are meaningless, as people use
       // `num` to mean "any kind of number" rather than "could be null".
       // The core libraries especially suffer from this problem, with many of
       // the `num` methods returning `num`.
       if (!rules.isNonNullableType(from) && rules.isNonNullableType(to)) {
         // Converting from a nullable number to a non-nullable number
         // only requires a null check.
         return js.call('dart.notNull(#)', _visit(node.expression));
       } else {
         // A no-op in JavaScript.
         return _visit(node.expression);
       }
     }
 
     return _emitCast(node.expression, to);
   }
 
-  // TODO(vsm): This should go away in the future.  I'm passing in the type
-  // as a String for now to avoid breaking any existing code.  In most cases,
-  // we currently throw for function types.
-  @override
-  visitClosureWrapBase(ClosureWrapBase node) {
-    var expression = _visit(node.expression);
-    var typeString = js.escapedString(node.convertedType.toString());
-    return js.call('dart.closureWrap(#, #)', [expression, typeString]);
-  }
-
-  @override
-  visitAsExpression(AsExpression node) =>
-      _emitCast(node.expression, node.type.type);
-
   _emitCast(Expression node, DartType type) =>
       js.call('dart.as(#)', [[_visit(node), _emitTypeName(type)]]);
 
   @override
   visitIsExpression(IsExpression node) {
     // Generate `is` as `dart.is` or `typeof` depending on the RHS type.
     JS.Expression result;
     var type = node.type.type;
     var lhs = _visit(node.expression);
     var typeofName = _jsTypeofName(type);
@@ skipping 2038 matching lines @@
   }
 
   DartType getStaticType(Expression e) => rules.getStaticType(e);
 
   static bool _needsImplicitThis(Element e) =>
       e is PropertyAccessorElement && !e.variable.isStatic ||
           e is ClassMemberElement && !e.isStatic && e is! ConstructorElement;
 }
 
 class JSGenerator extends CodeGenerator {
-  final JSCodeOptions options;
+  final CompilerOptions options;
 
   /// For fast lookup of extension methods, we first check the name, then do a
   /// (possibly expensive) subtype test to see if it matches one of the types
   /// that declares that method.
   final _extensionMethods = new HashMap<String, List<InterfaceType>>();
 
   JSGenerator(String outDir, Uri root, TypeRules rules, this.options)
       : super(outDir, root, rules) {
 
     // TODO(jacobr): determine the the set of types with extension methods from
     // the annotations rather than hard coding the list once the analyzer
     // supports summaries.
     var extensionTypes = [types.listType, types.iterableType];
     for (var type in extensionTypes) {
       type = fillDynamicTypeArgs(type, rules.provider);
       var e = type.element;
       var names = new HashSet<String>()
         ..addAll(e.methods.map((m) => m.name))
         ..addAll(e.accessors.map((m) => m.name));
       for (var name in names) {
         _extensionMethods.putIfAbsent(name, () => []).add(type);
       }
     }
   }
 
   TypeProvider get types => rules.provider;
 
   String generateLibrary(LibraryUnit unit, LibraryInfo info) {
-    var codegen = new JSCodegenVisitor(info, rules, _extensionMethods);
+    var codegen = new JSCodegenVisitor(info, rules, options, _extensionMethods);
     var module = codegen.emitLibrary(unit);
     var dir = path.join(outDir, jsOutputPath(info, root));
     return writeJsLibrary(module, dir, emitSourceMaps: options.emitSourceMaps);
   }
 }
 
 /// Choose a canonical name from the library element.
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
@@ skipping 22 matching lines @@
   return filepath;
 }
 
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;