Skeleton typedef type implementation

lib/compiler/implementation/js_backend/native_emitter.dart

 // Copyright (c) 2012, 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.
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
 
   // Classes that participate in dynamic dispatch. These are the
@@ skipping 166 matching lines @@
                                           List<String> argumentsBuffer) {
     FunctionSignature parameters = member.computeSignature(compiler);
     Element converter =
         compiler.findHelper(const SourceString('convertDartClosureToJS'));
     String closureConverter = compiler.namer.isolateAccess(converter);
     parameters.forEachParameter((Element parameter) {
       String name = parameter.name.slowToString();
       // If [name] is not in [argumentsBuffer], then the parameter is
       // an optional parameter that was not provided for that stub.
       if (argumentsBuffer.indexOf(name) == -1) return;
-      Type type = parameter.computeType(compiler);
+      Type type = parameter.computeType(compiler).unalias(compiler);
       if (type is FunctionType) {
+        // The parameter type is a function type either directly or through
+        // typedef(s).
         int arity = type.computeArity();
         code.add('  $name = $closureConverter($name, $arity);\n');
       }
     });
   }
 
   String generateParameterStub(Element member,
                                String invocationName,
                                String stubParameters,
                                List<String> argumentsBuffer,
@@ skipping 153 matching lines @@
 
       nativeBuffer.add('})();\n');
     }
   }
 
   bool isSupertypeOfNativeClass(Element element) {
     if (element.isTypeVariable()) {
       compiler.cancel("Is check for type variable", element: element);
       return false;
     }
-    if (element.computeType(compiler) is FunctionType) return false;
+    if (element.computeType(compiler).unalias(compiler) is FunctionType) {
+      // The element type is a function type either directly or through
+      // typedef(s).
+      return false;
+    }
 
     if (!element.isClass()) {
       compiler.cancel("Is check does not handle element", element: element);
       return false;
     }
 
     return subtypes[element] !== null;
   }
 
   bool requiresNativeIsCheck(Element element) {
@@ skipping 53 matching lines @@
         if (!first) targetBuffer.add(",\n");
         targetBuffer.add(" $name: $function");
         first = false;
       });
       targetBuffer.add("\n});\n\n");
     }
     targetBuffer.add('$nativeBuffer');
     targetBuffer.add('\n');
   }
 }