fixes detection of SDK libraries

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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 73 matching lines @@
 
   /// The name for the library's exports inside itself.
   /// `exports` was chosen as the most similar to ES module patterns.
   final _exportsVar = new JS.TemporaryId('exports');
   final _namedArgTemp = new JS.TemporaryId('opts');
 
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
+  /// _interceptors.JSArray<E>, used for List literals.
+  ClassElement _jsArray;
+
   JSCodegenVisitor(AbstractCompiler compiler, this.libraryInfo,
       this._extensionTypes, this._fieldsNeedingStorage)
       : compiler = compiler,
         options = compiler.options,
         rules = compiler.rules,
         root = compiler.entryPointUri {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
+
+    var context = compiler.context;
+    var src = context.sourceFactory.forUri('dart:_interceptors');
+    var interceptors = context.computeLibraryElement(src);
+    _jsArray = interceptors.getType('JSArray');
   }
 
   LibraryElement get currentLibrary => libraryInfo.library;
   TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
     String jsDefaultValue = null;
 
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, compiler).reify();
@@ skipping 1426 matching lines @@
       code = '#.#(#)';
     }
 
     return js.call(
         code, [_visit(target), memberName, _visit(node.argumentList)]);
   }
 
   /// Emits code for the `JS(...)` builtin.
   _emitForeignJS(MethodInvocation node) {
     var e = node.methodName.staticElement;
-    if (e is FunctionElement &&
-        e.library.name == '_foreign_helper' &&
-        e.name == 'JS') {
+    if (isInlineJS(e)) {
       var args = node.argumentList.arguments;
       // arg[0] is static return type, used in `RestrictedStaticTypeAnalyzer`
       var code = args[1] as StringLiteral;
 
       var template = js.parseForeignJS(code.stringValue);
       var result = template.instantiate(_visitList(args.skip(2)));
       // `throw` is emitted as a statement by `parseForeignJS`.
       assert(result is JS.Expression || node.parent is ExpressionStatement);
       return result;
     }
@@ skipping 308 matching lines @@
     } else if (expr is PostfixExpression) {
       type = getStaticType(expr.operand);
     }
     if (type != null && _isJSBuiltinType(type)) {
       return true;
     }
     if (expr is MethodInvocation) {
       // TODO(vsm): This logic overlaps with the resolver.
       // Where is the best place to put this?
       var e = expr.methodName.staticElement;
-      if (e is FunctionElement &&
-          e.library.name == '_foreign_helper' &&
-          e.name == 'JS') {
+      if (isInlineJS(e)) {
         // Fix types for JS builtin calls.
         //
         // This code was taken from analyzer. It's not super sophisticated:
         // only looks for the type name in dart:core, so we just copy it here.
         //
         // TODO(jmesserly): we'll likely need something that can handle a wider
         // variety of types, especially when we get to JS interop.
         var args = expr.argumentList.arguments;
         var first = args.isNotEmpty ? args.first : null;
         if (first is SimpleStringLiteral) {
@@ skipping 583 matching lines @@
     return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
     emitList() {
       JS.Expression list = new JS.ArrayInitializer(_visitList(node.elements));
       ParameterizedType type = node.staticType;
       var elementType = type.typeArguments.single;
       if (elementType != types.dynamicType) {
+        // dart.list helper internally depends on _interceptors.JSArray.
+        _loader.declareBeforeUse(_jsArray);
         list = js.call('dart.list(#, #)', [list, _emitTypeName(elementType)]);
       }
       return list;
     }
     if (node.constKeyword != null) return _emitConst(emitList);
     return emitList();
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
@@ skipping 279 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }