Initial support for runtime function types and type checking

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 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 286 matching lines @@
     if (rules.isBoolType(t)) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     // If we've already emitted this class, skip it.
     var type = node.element.type;
     if (_pendingClasses.remove(node.element) == null) return null;
 
-    var classDecl = new JS.ClassDeclaration(new JS.ClassExpression(
-        new JS.Identifier(type.name),
-        _emitTypeName(rules.provider.functionType), []));
+    var name = type.name;
+    var result = js.statement('let # = dart.typedef(#, () => #);', [
+      new JS.Identifier(name),
+      js.string(name, "'"),
+      _emitTypeName(node.element.type, lowerTypedef: true)
+    ]);
 
-    return _finishClassDef(type, classDecl);
+    return _finishClassDef(type, result);
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     // If we've already emitted this class, skip it.
     var type = node.element.type;
     if (_pendingClasses.remove(node.element) == null) return null;
@@ skipping 764 matching lines @@
       /// The renamer would handle this, but it would prefer to rename the
       /// temporary used for the private symbol. Instead rename the parameter.
       return new JSTemporary('${name.substring(1)}');
     }
 
     if (_isTemporary(e)) return new JSTemporary(e.name);
 
     return new JS.Identifier(name);
   }
 
-  JS.Expression _emitTypeName(DartType type) {
+  JS.ArrayInitializer _emitTypeNames(List<DartType> types) {
+    return new JS.ArrayInitializer(types.map(_emitTypeName).toList());
+  }
+
+  JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
+    var properties = <JS.Property>[];
+    types.forEach((name, type) {
+      var key = new JS.LiteralString(name);
+      var value = _emitTypeName(type);
+      properties.add(new JS.Property(key, value));
+    });
+    return new JS.ObjectInitializer(properties);
+  }
+
+  JS.Expression _emitTypeName(DartType type, {bool lowerTypedef: false}) {
+    // The void and dynamic types are not defined in core.
+    if (type.isVoid) {
+      return js.call('dart.void');
+    } else if (type.isDynamic) {
+      return js.call('dart.dynamic');
+    }
+
     var name = type.name;
     var element = type.element;
-    if (name == '') {
+    if (name == '' || lowerTypedef && type is FunctionType) {
+      if (type is FunctionType) {
+        // TODO(vsm): Support all parameter types.
+        var returnType = type.returnType;
+        var parameterTypes = type.normalParameterTypes;
+        var optionalTypes = type.optionalParameterTypes;
+        var namedTypes = type.namedParameterTypes;
+        if (namedTypes.isEmpty) {
+          if (optionalTypes.isEmpty) {
+            return js.call('dart.functionType(#, #)', [
+              _emitTypeName(returnType),
+              _emitTypeNames(parameterTypes)
+            ]);
+          } else {
+            return js.call('dart.functionType(#, #, #)', [
+              _emitTypeName(returnType),
+              _emitTypeNames(parameterTypes),
+              _emitTypeNames(optionalTypes)
+            ]);
+          }
+        } else {
+          assert(optionalTypes.isEmpty);
+          return js.call('dart.functionType(#, #, #)', [
+            _emitTypeName(returnType),
+            _emitTypeNames(parameterTypes),
+            _emitTypeProperties(namedTypes)
+          ]);
+        }
+      }
       // TODO(jmesserly): remove when we're using coercion reifier.
       return _unimplementedCall('Unimplemented type $type');
     }
 
     var typeArgs = null;
     if (type is ParameterizedType) {
       // TODO(jmesserly): this is a workaround for an analyzer bug, see:
       // https://github.com/dart-lang/dev_compiler/commit/a212d59ad046085a626dd8d16881cdb8e8b9c3fa
       if (type is! FunctionType || element is FunctionTypeAlias) {
         var args = type.typeArguments;
@@ skipping 1384 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }