Fix for the js-interop crash

pkg/compiler/lib/src/ssa/builder.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 SsaFunctionCompiler implements FunctionCompiler {
   final SsaCodeGeneratorTask generator;
   final SsaBuilderTask builder;
   final SsaOptimizerTask optimizer;
@@ skipping 5846 matching lines @@
               ..sourceInformation = sourceInformation);
     }
   }
 
   bool _hasNamedParameters(FunctionElement function) {
     FunctionSignature params = function.functionSignature;
     return params.optionalParameterCount > 0
         && params.optionalParametersAreNamed;
   }
 
-  HForeignCode invokeJsInteropFunction(Element element,
+  HForeignCode invokeJsInteropFunction(FunctionElement element,
                                        List<HInstruction> arguments,
                                        SourceInformation sourceInformation) {
     assert(backend.isJsInterop(element));
     nativeEmitter.nativeMethods.add(element);
     String templateString;
 
     if (element.isFactoryConstructor &&
         backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass)) {
       // Factory constructor that is syntactic sugar for creating a JavaScript
       // object literal.
@@ skipping 33 matching lines @@
         <HInstruction>[]);
     add(target);
     // Strip off trailing arguments that were not specified.
     // we could assert that the trailing arguments are all null.
     // TODO(jacobr): rewrite named arguments to an object literal matching
     // the factory constructor case.
     arguments = arguments.where((arg) => arg != null).toList();
     var inputs = <HInstruction>[target]..addAll(arguments);
 
     js.Template codeTemplate;
+    DartType type = element.type.returnType;
     if (element.isGetter) {
       codeTemplate = js.js.parseForeignJS("#");
     } else if (element.isSetter) {
       codeTemplate = js.js.parseForeignJS("# = #");
     } else {
-      FunctionElement function = element;
-      FunctionSignature params = function.functionSignature;
+      FunctionSignature params = element.functionSignature;
 
       var argsStub = <String>[];
       for (int i = 0; i < arguments.length; i++) {
         argsStub.add('#');
       }
 
       if (element.isConstructor) {
         codeTemplate = js.js.parseForeignJS("new #(${argsStub.join(",")})");
+        type = element.enclosingClass.thisType;
       } else {
         codeTemplate = js.js.parseForeignJS("#(${argsStub.join(",")})");
       }
     }
 
+    // Note: here we are trusting the declared type by default to keep the
+    // codegen behavior consistent with the resolution behavior. Currently the
+    // NativeResolutionEnqueuer will trust the types by default (since this is
+    // what we always did for native APIs in dart:html). We could change both to
+    // be more conservative, but that could bring in a lot more code than what
+    // we want.

[Jacob, 2015/11/20 00:50:34]

I thought in resolution we were treating each of these methods as returning any
js class. Perhaps we should fix the bug in that direction instead of here? 

[Siggi Cherem (dart-lang), 2015/11/20 01:06:17]

Good question - we have been debating about this too. 

I like that it would make things safer, but we also were worried that if we do
that we will include everything that extends from JavaScriptObject pretty
quickly.

I just realized though that by including JavaScriptObject, you still don't bring
anything from the DOM (since those are extending directly from Interceptor) -
Stephen, if that's the case, does that lessen your worry? 

[Siggi Cherem (dart-lang), 2015/11/20 01:56:15]

I made a CL with the alternative approach, I'm still not convinced though. Here
is the link https://codereview.chromium.org/1457383003/.

If we really want tree-shaking, we could expose an interop identify function
that enables side-casts without the tree-shaking cost.

     var nativeBehavior = new native.NativeBehavior()
       ..codeTemplate = codeTemplate
-      ..typesReturned.add(
-          helpers.jsJavaScriptObjectClass.thisType)
-      ..typesInstantiated.add(
-          helpers.jsJavaScriptObjectClass.thisType)
+      ..typesReturned.add(type)
+      ..typesInstantiated.add(type)
       ..sideEffects.setAllSideEffects();
     return new HForeignCode(
         codeTemplate,
         backend.dynamicType, inputs,
         nativeBehavior: nativeBehavior)
       ..sourceInformation = sourceInformation;
   }
 
   void pushInvokeStatic(ast.Node location,
                         Element element,
@@ skipping 3204 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.helpers.DynamicRuntimeType;
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }