Remove support for interface in dart2js.

tests/compiler/dart2js/dart_backend_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 'dart:uri';
 import 'parser_helper.dart';
 import 'mock_compiler.dart';
 import '../../../sdk/lib/_internal/compiler/compiler.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart' as leg;
 import '../../../sdk/lib/_internal/compiler/implementation/dart_backend/dart_backend.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/tree/tree.dart';
 
 const coreLib = r'''
 library corelib;
 class Object {}
-interface bool {}
-interface num {}
-interface int extends num {}
-interface double extends num {}
+class bool {}
+class num {}
+class int extends num {}
+class double extends num {}
 abstract class String {}
-interface Function {}
-interface List<T> {}
-interface Map<K,V> {}
-interface Closure {}
-interface Dynamic_ {}
-interface Null {}
-interface TypeError {}
+class Function {}
+class List<T> {}
+class Map<K,V> {}
+class Closure {}
+class Dynamic_ {}
+class Null {}
+class TypeError {}
 class Type {}
 class LinkedHashMap {}
 class Math {
   static double parseDouble(String s) => 1.0;
 }
 print(x) {}
 identical(a, b) => true;
 ''';
 
 const ioLib = r'''
@@ skipping 338 matching lines @@
     'class A{foo(){}}'
     'p_topfoo(){var x=5;}'
     'class p_A{num foo(){}p_A.fromFoo(){}A myliba;List<p_A> mylist;}'
     'A getA()=>null;'
     'main(){var a=new A();a.foo();var b=new p_A.fromFoo();b.foo();'
         'var GREATVAR=b.myliba;b.mylist;a=getA();p_topfoo();topfoo();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
       continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
-testDefaultClassWithArgs() {
-  testDart2Dart('main(){var result=new IA<String>();}'
-      'interface IA<T> default A<T extends Object>{IA();}'
-      'class A<T extends Object> implements IA<T>{factory A(){}}');
-}
-
 testClassExtendsWithArgs() {
   testDart2Dart('main(){new B<Object>();}'
     'class A<T extends Object>{}'
     'class B<T extends Object> extends A<T>{}');
 }
 
 testStaticInvocation() {
   testDart2Dart('main(){var x=Math.parseDouble("1");}');
 }
 
@@ skipping 57 matching lines @@
   FunctionElement mainElement = compiler.mainApp.find(leg.Compiler.MAIN);
   compiler.processQueue(compiler.enqueuer.resolution, mainElement);
   PlaceholderCollector collector = collectPlaceholders(compiler, mainElement);
   FunctionExpression mainNode = mainElement.parseNode(compiler);
   FunctionExpression fooNode = mainNode.body.statements.nodes.head.function;
   LocalPlaceholder fooPlaceholder =
       collector.functionScopes[mainElement].localPlaceholders.first;
   Expect.isTrue(fooPlaceholder.nodes.contains(fooNode.name));
 }
 
-testDefaultClassNamePlaceholder() {
-  var src = '''
-interface I default C{
-  I();
-}
-
-class C {
-  I() {}
-}
-
-main() {
-  new I();
-}
-''';
-  MockCompiler compiler = new MockCompiler();
-  compiler.parseScript(src);
-  ClassElement interfaceElement = compiler.mainApp.find(buildSourceString('I'));
-  interfaceElement.ensureResolved(compiler);
-  PlaceholderCollector collector =
-      collectPlaceholders(compiler, interfaceElement);
-  ClassNode interfaceNode = interfaceElement.parseNode(compiler);
-  Node defaultTypeNode = interfaceNode.defaultClause.typeName;
-  ClassElement classElement = compiler.mainApp.find(buildSourceString('C'));
-  // Check that 'C' in default clause of I gets into placeholders.
-  Expect.isTrue(collector.elementNodes[classElement].contains(defaultTypeNode));
-}
-
 testTypeVariablesAreRenamed() {
   // Somewhat a hack: we require all the references of the identifier
   // to be renamed in the same way for the whole library. Hence
   // if we have a class and type variable with the same name, they
   // both should be renamed.
   var librarySrc = '''
 library mylib;
 typedef void MyFunction<T extends num>(T arg);
 class T {}
 class B<T> {}
@@ skipping 28 matching lines @@
     'main(){p_MyFunction myf1;MyFunction myf2;new p_A<int>().f;'
         'new p_T();new A<int>().f;new T();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
       continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testClassTypeArgumentBound() {
   var librarySrc = '''
 library mylib;
 
-interface I {}
+class I {}
 class A<T extends I> {}
 
 ''';
   var mainSrc = '''
 import 'mylib.dart' as mylib;
 
-interface I {}
+class I {}
 class A<T extends I> {}
 
 main() {
   new A();
   new mylib.A();
 }
 ''';
   var expectedResult =
-    'interface I{}'
+    'class I{}'
     'class A<T extends I>{}'
-    'interface p_I{}'
+    'class p_I{}'
     'class p_A<p_T extends p_I>{}'
     'main(){new p_A();new A();}';
   testDart2DartWithLibrary(mainSrc, librarySrc,
       continuation: (String result) { Expect.equals(expectedResult, result); });
 }
 
 testDoubleMains() {
   var librarySrc = '''
 library mylib;
 main() {}
@@ skipping 162 matching lines @@
   testSimpleTopLevelClass();
   testClassWithSynthesizedConstructor();
   testClassWithMethod();
   testExtendsImplements();
   testVariableDefinitions();
   testGetSet();
   testAbstractClass();
   testConflictSendsRename();
   testNoConflictSendsRename();
   testConflictLibraryClassRename();
-  testDefaultClassWithArgs();
   testClassExtendsWithArgs();
   testStaticInvocation();
   testLibraryGetSet();
   testFieldTypeOutput();
-  testDefaultClassNamePlaceholder();
   testTypeVariablesAreRenamed();
   testClassTypeArgumentBound();
   testDoubleMains();
   testStaticAccessIoLib();
   testLocalFunctionPlaceholder();
   testMinification();
   testClosureLocalsMinified();
   testParametersMinified();
   testDeclarationTypePlaceholders();
   testPlatformLibraryMemberNamesAreFixed();
   testConflictsWithCoreLib();
   testUnresolvedNamedConstructor();
 }