Support user generated custom native JS classes.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import '../compiler.dart' show
     Compiler;
 import '../constants/constant_constructors.dart';
 import '../constants/constructors.dart';
@@ skipping 207 matching lines @@
           ? enclosingElement.name
           : '${enclosingElement.kind}?';
       return '$kind($holderName#${nameText})';
     } else {
       return '$kind(${nameText})';
     }
   }
 
   String _fixedBackendName = null;
   bool _isNative = false;
-  bool get isNative => _isNative;
-  bool get hasFixedBackendName => _fixedBackendName != null;
-  String get fixedBackendName => _fixedBackendName;
+  String _jsInteropName = null;
+
+  bool get isJsInterop => _jsInteropName != null;
+
+  void setJsInterop(String name) { _jsInteropName = name; }
+
+  bool get isNative => _isNative || isJsInterop;
+  bool get hasFixedBackendName => fixedBackendName != null || isJsInterop;
+
+  String get fixedBackendName {
+    if (_fixedBackendName != null) return _fixedBackendName;
+    if (isJsInterop) {
+      String nameHelper(e) {
+        if (e._jsInteropName != null && e._jsInteropName.isNotEmpty)
+          return e._jsInteropName;
+        return e.isLibrary ? 'self' : e.name;
+      }
+
+      var sb = new StringBuffer();
+      if (!isLibrary && !isInstanceMember) {
+        sb..write(nameHelper(library))..write('.');
+        if (enclosingClass != null && enclosingClass != this) {
+          sb.write(nameHelper(enclosingClass));
+          if (!isConstructor) sb.write('.');
+        }
+      }
+      if (!isConstructor) sb.write(nameHelper(this));

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

are named constructors not supported?

[Jacob, 2015/10/01 00:47:33]

they are supported.
Suppose you have a JavaScript class GoogleMap.

you could write
@Js
class GoogleMap {
  external GoogleMap(num lat, num long);
  external GoogleMap.fromPoint(Point p);
}

Both external constructors will compile down to calls to JS
new GoogleMap(someArgs...);

For factory constructors it could be reasonable to allow specifying a custom JS
name for the JavaScript static method that is invoked but I don't think that is
really worth it. Currently factory constructors are being interpreted as
generating a JS literal but it is a bit adhoc.

+      return sb.toString();
+    }
+    return null;
+  }
+
   // Marks this element as a native element.
   void setNative(String name) {
     _isNative = true;
     _fixedBackendName = name;
   }
 
   FunctionElement asFunctionElement() => null;
 
   bool get isAbstract => modifiers.isAbstract;
 
@@ skipping 1554 matching lines @@
     });
     return functionSignatureCache;
   }
 
   FunctionSignature get functionSignature {
     assert(invariant(this, functionSignatureCache != null,
         message: "Function signature has not been computed for $this."));
     return functionSignatureCache;
   }
 
+  /**
+   * An function is part of JsInterop if it has a jsInteropName annotation or it
+   * is an external class or top level member of a class or library tagged as
+   * JsInterop.
+   */
+  bool get isJsInterop {
+    if (super.isJsInterop) return true;

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

are there any cases where this is true if the two conditions below are false? or
can we delete this line?

[Jacob, 2015/10/01 00:47:33]

yes. super.isJsInterop checks whether the member itself has a @Js annotation.

+    if (isClassMember) return contextClass.isJsInterop && isExternal;

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

it might be worth checking for isExternal upfront, that way we skip all
non-external class members and top-levels 

[Jacob, 2015/10/01 00:47:33]

 done.

+    if (isTopLevel) return library.isJsInterop && isExternal;
+    return false;
+  }
+
   List<ParameterElement> get parameters {
     // TODO(johnniwinther): Store the list directly, possibly by using List
     // instead of Link in FunctionSignature.
     List<ParameterElement> list = <ParameterElement>[];
     functionSignature.forEachParameter((e) => list.add(e));
     return list;
   }
 
   FunctionType computeType(Compiler compiler) {
     if (typeCache != null) return typeCache;
@@ skipping 597 matching lines @@
   }
 
   void forEachBackendMember(void f(Element member)) {
     backendMembers.forEach(f);
   }
 
   bool implementsFunction(Compiler compiler) {
     return asInstanceOf(compiler.functionClass) != null || callType != null;
   }
 
-  bool get isNative => nativeTagInfo != null;
+  bool get isNative => nativeTagInfo != null || isJsInterop;
 
   void setNative(String name) {
     // TODO(johnniwinther): Assert that this is only called once. The memory
     // compiler copies pre-processed elements into a new compiler through
     // [Compiler.onLibraryScanned] and thereby causes multiple calls to this
     // method.
     assert(invariant(this, nativeTagInfo == null || nativeTagInfo == name,
         message: "Native tag info set inconsistently on $this: "
                  "Existing name '$nativeTagInfo', new name '$name'."));
     nativeTagInfo = name;
@@ skipping 481 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }