Move dart2js from sdk/lib/_internal/compiler to pkg/compiler

tests/compiler/dart2js/resolver_test.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.
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import "package:async_helper/async_helper.dart";
 import 'dart:collection';
 
-import "package:compiler/implementation/resolution/resolution.dart";
+import "package:compiler/src/resolution/resolution.dart";
 import "compiler_helper.dart";
 import "parser_helper.dart";
 
-import 'package:compiler/implementation/dart_types.dart';
-import 'package:compiler/implementation/elements/modelx.dart';
+import 'package:compiler/src/dart_types.dart';
+import 'package:compiler/src/elements/modelx.dart';
 import 'link_helper.dart';
 
 Node buildIdentifier(String name) => new Identifier(scan(name));
 
 Node buildInitialization(String name) =>
   parseBodyCode('$name = 1',
       (parser, tokens) => parser.parseOptionallyInitializedIdentifier(tokens));
 
 createLocals(List variables) {
   var locals = <Node>[];
@@ skipping 557 matching lines @@
 
     Expect.equals(barElement.computeType(compiler),
                   fooElement.interfaces.head);
     Expect.equals(1, length(fooElement.interfaces));
   });
 }
 
 Future testTwoInterfaces() {
   return MockCompiler.create((MockCompiler compiler) {
     compiler.parseScript(
-        """abstract class I1 {} 
-           abstract class I2 {} 
+        """abstract class I1 {}
+           abstract class I2 {}
            class C implements I1, I2 {}""");
     compiler.resolveStatement("Foo bar;");
 
     ClassElement c = compiler.mainApp.find('C');
     Element i1 = compiler.mainApp.find('I1');
     Element i2 = compiler.mainApp.find('I2');
 
     Expect.equals(2, length(c.interfaces));
     Expect.equals(i1.computeType(compiler), at(c.interfaces, 0));
     Expect.equals(i2.computeType(compiler), at(c.interfaces, 1));
@@ skipping 149 matching lines @@
       compiler.resolver.resolve(mainElement);
       Expect.equals(0, compiler.warnings.length);
       Expect.equals(0, compiler.errors.length);
       ClassElement aElement = compiler.mainApp.find("A");
       Link<DartType> supertypes = aElement.allSupertypes;
       Expect.equals(<String>['B', 'C', 'Object'].toString(),
                     asSortedStrings(supertypes).toString());
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""class A<T> {}
-                              class B<Z,W> extends A<int> 
+                              class B<Z,W> extends A<int>
                                   implements I<Z,List<W>> {}
                               class I<X,Y> {}
                               class C extends B<bool,String> {}
                               main() { return new C(); }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       Expect.equals(0, compiler.warnings.length);
       Expect.equals(0, compiler.errors.length);
       ClassElement aElement = compiler.mainApp.find("C");
       Link<DartType> supertypes = aElement.allSupertypes;
@@ skipping 289 matching lines @@
       }""";
   asyncTest(() => compileScript(script2).then((compiler) {
     expect(compiler,
         [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS],
         [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD]);
   }));
 }