Fix warning spotted by dartc, and make the HType understand the dynamic class.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1510 matching lines @@
         } else if (target == backend.jsArrayRemoveLast) {
           methodName = 'pop';
         } else if (target == backend.jsStringSplit) {
           methodName = 'split';
           // Split returns a List, so we make sure the backend knows the
           // list class is instantiated.
           world.registerInstantiatedClass(compiler.listClass);
         } else if (target == backend.jsStringConcat) {
           push(new js.Binary('+', object, arguments[0]), node);
           return;
-        } else if (target.isNative() && !compiler.enableTypeAssertions) {
+        } else if (target.isNative()
+                   && !compiler.enableTypeAssertions
+                   && target.isFunction()) {
           // Enable direct calls to a native method only if we don't
           // run in checked mode, where the Dart version may have
           // type annotations on parameters and return type that it
           // should check.
           // Also check that the parameters are not functions: it's
           // the callee that will translate them to JS functions.
           // TODO(ngeoffray): There are some cases where we could
           // still inline in checked mode if we know the arguments
           // have the right type. And we could do the closure
           // conversion as well as the return type annotation check.
           bool canInlineNativeCall = true;
-          target.computeSignature(compiler).forEachParameter((Element element) {
+          FunctionElement function = target;
+          function.computeSignature(compiler).forEachParameter((Element element) {
             DartType type = element.computeType(compiler).unalias(compiler);
             if (type is FunctionType) {
               canInlineNativeCall = false;
             }
           });
           if (canInlineNativeCall) {
             methodName = target.fixedBackendName();
           }
         }
       }
@@ skipping 1456 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }